zeldon/mineping
1
0
Fork 0
mirror of https://github.com/minescope/mineping.git synced 2025-01-13 05:36:48 +03:00
Code Issues Packages Projects Releases Wiki Activity

docs: update references to wiki.vg

Browse Source 
wiki.vg has been shut down and is in the process of being merged into minecraft.wiki
This commit is contained in:
Timofey Gelazoniya 2024-12-28 22:47:11 +03:00
parent 838ffc497a
commit 9469564736
Signed by: zeldon
GPG Key ID: 047886915281DD2A
4 changed files with 333 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

183
lib/bedrock.js
View File

@ -1,12 +1,12 @@
/** /**
* Implementation of the RakNet ping/pong protocol. * Implementation of the RakNet ping/pong protocol.
* @see https://wiki.vg/Raknet_Protocol * @see https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Raknet_Protocol
*/ */
'use strict'; "use strict";
import dgram from 'node:dgram'; import dgram from "node:dgram";
import crypto from 'node:crypto' import crypto from "node:crypto";
const MAGIC = "00ffff00fefefefefdfdfdfd12345678"; const MAGIC = "00ffff00fefefefefdfdfdfd12345678";
const START_TIME = new Date().getTime(); const START_TIME = new Date().getTime();
@ -15,47 +15,51 @@ const START_TIME = new Date().getTime();
* Creates an Unconnected Ping packet. * Creates an Unconnected Ping packet.
* @param {number} pingId * @param {number} pingId
* @returns {Buffer} * @returns {Buffer}
* @see {@link https://wiki.vg/Raknet_Protocol#Unconnected_Ping} * @see {@link https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Raknet_Protocol#Unconnected_Ping}
*/ */
const createUnconnectedPingFrame = (timestamp) => { const createUnconnectedPingFrame = (timestamp) => {
const buffer = Buffer.alloc(33); const buffer = Buffer.alloc(33);
buffer.writeUInt8(0x01, 0); // Packet ID buffer.writeUInt8(0x01, 0); // Packet ID
buffer.writeBigInt64LE(BigInt(timestamp), 1); // Timestamp buffer.writeBigInt64LE(BigInt(timestamp), 1); // Timestamp
Buffer.from(MAGIC, "hex").copy(buffer, 9); // OFFLINE_MESSAGE_DATA_ID (Magic) Buffer.from(MAGIC, "hex").copy(buffer, 9); // OFFLINE_MESSAGE_DATA_ID (Magic)
Buffer.from(crypto.randomBytes(8)).copy(buffer, 25); // Client GUID Buffer.from(crypto.randomBytes(8)).copy(buffer, 25); // Client GUID
return buffer; return buffer;
}; };
/** /**
* Extract Modt from Unconnected Pong Packet and convert to an object * Extract Modt from Unconnected Pong Packet and convert to an object
* @param {Buffer} unconnectedPongPacket * @param {Buffer} unconnectedPongPacket
* @returns {Object} * @returns {Object}
* @see {@link https://wiki.vg/Raknet_Protocol#Unconnected_Pong} * @see {@link https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Raknet_Protocol#Unconnected_Pong}
*/ */
const extractModt = (unconnectedPongPacket) => { const extractModt = (unconnectedPongPacket) => {
// Skip everything to Modt // Skip everything to Modt
const offset = 33; const offset = 33;
const length = unconnectedPongPacket.readUInt16BE(offset); const length = unconnectedPongPacket.readUInt16BE(offset);
let modt = unconnectedPongPacket.toString("utf-8", offset + 2, offset + 2 + length); let modt = unconnectedPongPacket.toString(
"utf-8",
offset + 2,
offset + 2 + length
);
const components = modt.split(';'); const components = modt.split(";");
const parsedComponents = { const parsedComponents = {
edition: components[0], edition: components[0],
name: components[1], name: components[1],
version: { version: {
protocolVersion: Number(components[2]), protocolVersion: Number(components[2]),
minecraftVersion: components[3], minecraftVersion: components[3],
}, },
players: { players: {
online: Number(components[4]), online: Number(components[4]),
max: Number(components[5]) max: Number(components[5]),
}, },
serverId: components[6], serverId: components[6],
mapName: components[7], mapName: components[7],
gameMode: components[8] gameMode: components[8],
}; };
return parsedComponents; return parsedComponents;
}; };
/** /**
@ -66,63 +70,63 @@ const extractModt = (unconnectedPongPacket) => {
* @param {number} [timeout=5000] - The timeout duration in milliseconds. * @param {number} [timeout=5000] - The timeout duration in milliseconds.
*/ */
const ping = (host, port = 19132, cb, timeout = 5000) => { const ping = (host, port = 19132, cb, timeout = 5000) => {
const socket = dgram.createSocket('udp4'); const socket = dgram.createSocket("udp4");
// Set manual timeout interval. // Set manual timeout interval.
// This ensures the connection will NEVER hang regardless of internal state // This ensures the connection will NEVER hang regardless of internal state
const timeoutTask = setTimeout(() => { const timeoutTask = setTimeout(() => {
socket.emit('error', new Error('Socket timeout')); socket.emit("error", new Error("Socket timeout"));
}, timeout); }, timeout);
const closeSocket = () => { const closeSocket = () => {
socket.close(); socket.close();
clearTimeout(timeoutTask); clearTimeout(timeoutTask);
}; };
// Generic error handler // Generic error handler
// This protects multiple error callbacks given the complex socket state // This protects multiple error callbacks given the complex socket state
// This is mostly dangerous since it can swallow errors // This is mostly dangerous since it can swallow errors
let didFireError = false; let didFireError = false;
/** /**
* Handle any error that occurs during the ping process. * Handle any error that occurs during the ping process.
* @param {Error} err The error that occurred. * @param {Error} err The error that occurred.
*/ */
const handleError = (err) => { const handleError = (err) => {
closeSocket(); closeSocket();
if (!didFireError) { if (!didFireError) {
didFireError = true; didFireError = true;
cb(null, err); cb(null, err);
} }
}; };
try { try {
const ping = createUnconnectedPingFrame(new Date().getTime() - START_TIME); const ping = createUnconnectedPingFrame(new Date().getTime() - START_TIME);
socket.send(ping, 0, ping.length, port, host); socket.send(ping, 0, ping.length, port, host);
} catch (err) { } catch (err) {
handleError(err); handleError(err);
} }
socket.on('message', (pongPacket) => { socket.on("message", (pongPacket) => {
const id = pongPacket[0]; const id = pongPacket[0];
switch (id) { switch (id) {
case 0x1c: { case 0x1c: {
const modtObject = extractModt(pongPacket); const modtObject = extractModt(pongPacket);
closeSocket(); closeSocket();
cb(modtObject, null); cb(modtObject, null);
break; break;
} }
default: { default: {
handleError(new Error('Received unexpected packet')); handleError(new Error("Received unexpected packet"));
break; break;
} }
} }
}); });
socket.on('error', handleError); socket.on("error", handleError);
}; };
/** /**
@ -133,13 +137,18 @@ const ping = (host, port = 19132, cb, timeout = 5000) => {
* @returns {Promise<import('../types/index.js').BedrockPingResponse>} * @returns {Promise<import('../types/index.js').BedrockPingResponse>}
*/ */
export const pingBedrock = (host, options = {}) => { export const pingBedrock = (host, options = {}) => {
if (!host) throw new Error('Host argument is not provided'); if (!host) throw new Error("Host argument is not provided");
const { port = 19132, timeout = 5000 } = options; const { port = 19132, timeout = 5000 } = options;
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
ping(host, port, (res, err) => { ping(
err ? reject(err) : resolve(res); host,
}, timeout); port,
}); (res, err) => {
err ? reject(err) : resolve(res);
},
timeout
);
});
}; };

186
lib/java.js
View File

@ -1,12 +1,12 @@
/** /**
* Implementation of the Java Minecraft ping protocol. * Implementation of the Java Minecraft ping protocol.
* @see https://wiki.vg/Server_List_Ping * @see https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Server_List_Ping
*/ */
'use strict'; "use strict";
import net from 'node:net'; import net from "node:net";
import varint from './varint.js'; import varint from "./varint.js";
/** /**
* Ping a Minecraft Java server. * Ping a Minecraft Java server.
@ -17,102 +17,108 @@ import varint from './varint.js';
* @param {number} [protocolVersion=-1] The protocol version of the Java client. * @param {number} [protocolVersion=-1] The protocol version of the Java client.
*/ */
function ping(host, port = 25565, cb, timeout = 5000, protocolVersion = -1) { function ping(host, port = 25565, cb, timeout = 5000, protocolVersion = -1) {
const socket = net.createConnection(({ host, port })); const socket = net.createConnection({ host, port });
// Set manual timeout interval. // Set manual timeout interval.
// This ensures the connection will NEVER hang regardless of internal state // This ensures the connection will NEVER hang regardless of internal state
const timeoutTask = setTimeout(() => { const timeoutTask = setTimeout(() => {
socket.emit('error', new Error('Socket timeout')); socket.emit("error", new Error("Socket timeout"));
}, timeout); }, timeout);
const closeSocket = () => { const closeSocket = () => {
socket.destroy(); socket.destroy();
clearTimeout(timeoutTask); clearTimeout(timeoutTask);
}; };
// Generic error handler // Generic error handler
// This protects multiple error callbacks given the complex socket state // This protects multiple error callbacks given the complex socket state
// This is mostly dangerous since it can swallow errors // This is mostly dangerous since it can swallow errors
let didFireError = false; let didFireError = false;
/** /**
* Handle any error that occurs during the ping process. * Handle any error that occurs during the ping process.
* @param {Error} err The error that occurred. * @param {Error} err The error that occurred.
*/ */
const handleError = (err) => { const handleError = (err) => {
closeSocket(); closeSocket();
if (!didFireError) { if (!didFireError) {
didFireError = true; didFireError = true;
cb(null, err); cb(null, err);
} }
}; };
// #setNoDelay instantly flushes data during read/writes // #setNoDelay instantly flushes data during read/writes
// This prevents the runtime from delaying the write at all // This prevents the runtime from delaying the write at all
socket.setNoDelay(true); socket.setNoDelay(true);
socket.on('connect', () => { socket.on("connect", () => {
const handshake = varint.concat([ const handshake = varint.concat([
varint.encodeInt(0), varint.encodeInt(0),
varint.encodeInt(protocolVersion), varint.encodeInt(protocolVersion),
varint.encodeInt(host.length), varint.encodeInt(host.length),
varint.encodeString(host), varint.encodeString(host),
varint.encodeUShort(port), varint.encodeUShort(port),
varint.encodeInt(1) varint.encodeInt(1),
]); ]);
socket.write(handshake); socket.write(handshake);
const request = varint.concat([ const request = varint.concat([varint.encodeInt(0)]);
varint.encodeInt(0)
]);
socket.write(request); socket.write(request);
}); });
let incomingBuffer = Buffer.alloc(0); let incomingBuffer = Buffer.alloc(0);
socket.on('data', (data) => { socket.on("data", (data) => {
incomingBuffer = Buffer.concat([incomingBuffer, data]); incomingBuffer = Buffer.concat([incomingBuffer, data]);
// Wait until incomingBuffer is at least 5 bytes long to ensure it has captured the first VarInt value // Wait until incomingBuffer is at least 5 bytes long to ensure it has captured the first VarInt value
// This value is used to determine the full read length of the response // This value is used to determine the full read length of the response
// "VarInts are never longer than 5 bytes" // "VarInts are never longer than 5 bytes"
// https://wiki.vg/Data_types#VarInt_and_VarLong // https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Data_types#VarInt_and_VarLong
if (incomingBuffer.length < 5) { if (incomingBuffer.length < 5) {
return; return;
} }
let offset = 0; let offset = 0;
const packetLength = varint.decodeInt(incomingBuffer, offset); const packetLength = varint.decodeInt(incomingBuffer, offset);
// Ensure incomingBuffer contains the full response // Ensure incomingBuffer contains the full response
if (incomingBuffer.length - offset < packetLength) { if (incomingBuffer.length - offset < packetLength) {
return; return;
} }
const packetId = varint.decodeInt(incomingBuffer, varint.decodeLength(packetLength)); const packetId = varint.decodeInt(
incomingBuffer,
varint.decodeLength(packetLength)
);
if (packetId === 0) { if (packetId === 0) {
const data = incomingBuffer.subarray(varint.decodeLength(packetLength) + varint.decodeLength(packetId)); const data = incomingBuffer.subarray(
const responseLength = varint.decodeInt(data, 0); varint.decodeLength(packetLength) + varint.decodeLength(packetId)
const response = data.subarray(varint.decodeLength(responseLength), varint.decodeLength(responseLength) + responseLength); );
const responseLength = varint.decodeInt(data, 0);
const response = data.subarray(
varint.decodeLength(responseLength),
varint.decodeLength(responseLength) + responseLength
);
try { try {
const message = JSON.parse(response); const message = JSON.parse(response);
closeSocket(); closeSocket();
cb(message, null); cb(message, null);
} catch (err) { } catch (err) {
handleError(err); handleError(err);
} }
} else { } else {
handleError(new Error('Received unexpected packet')); handleError(new Error("Received unexpected packet"));
} }
}); });
socket.on('error', handleError); socket.on("error", handleError);
} }
/** /**
@ -123,13 +129,19 @@ function ping(host, port = 25565, cb, timeout = 5000, protocolVersion = -1) {
* @returns {Promise<import('../types/index.js').JavaPingResponse>} * @returns {Promise<import('../types/index.js').JavaPingResponse>}
*/ */
export function pingJava(host, options = {}) { export function pingJava(host, options = {}) {
if (!host) throw new Error('Host argument is not provided'); if (!host) throw new Error("Host argument is not provided");
const { port = 25565, timeout = 5000, protocolVersion = -1 } = options; const { port = 25565, timeout = 5000, protocolVersion = -1 } = options;
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
ping(host, port, (res, err) => { ping(
err ? reject(err) : resolve(res); host,
}, timeout, protocolVersion); port,
}); (res, err) => {
err ? reject(err) : resolve(res);
},
timeout,
protocolVersion
);
});
} }

208
lib/varint.js
View File

@ -1,127 +1,131 @@
// https://wiki.vg/Data_types // https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Protocol#Data_types
/** /**
* A utility object for encoding and decoding varints. * A utility object for encoding and decoding varints.
*/ */
const varint = { const varint = {
/** /**
* Encodes an integer value into a varint byte buffer. * Encodes an integer value into a varint byte buffer.
* @param {number} val - The integer value to encode. * @param {number} val - The integer value to encode.
* @returns {Buffer} * @returns {Buffer}
*/ */
encodeInt: (val) => { encodeInt: (val) => {
// "constInts are never longer than 5 bytes" // "VarInts are never longer than 5 bytes"
// https://wiki.vg/Data_types#constInt_and_constLong // https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Data_types#VarInt_and_VarLong
const buf = Buffer.alloc(5); const buf = Buffer.alloc(5);
let written = 0; let written = 0;
while (true) { while (true) {
const byte = val & 0x7F; const byte = val & 0x7f;
val >>>= 7; val >>>= 7;
if (val === 0) { if (val === 0) {
buf.writeUInt8(byte, written++); buf.writeUInt8(byte, written++);
break; break;
} }
buf.writeUInt8(byte | 0x80, written++); buf.writeUInt8(byte | 0x80, written++);
} }
return buf.slice(0, written); return buf.slice(0, written);
}, },
/** /**
* Encodes a string value into a UTF-8 byte buffer. * Encodes a string value into a UTF-8 byte buffer.
* @param {string} val - The string value to encode. * @param {string} val - The string value to encode.
* @returns {Buffer} * @returns {Buffer}
*/ */
encodeString: (val) => { encodeString: (val) => {
return Buffer.from(val, 'utf-8'); return Buffer.from(val, "utf-8");
}, },
/** /**
* Encodes an unsigned short value into a byte buffer. * Encodes an unsigned short value into a byte buffer.
* @param {number} val - The unsigned short value to encode. * @param {number} val - The unsigned short value to encode.
* @returns {Buffer} * @returns {Buffer}
*/ */
encodeUShort: (val) => { encodeUShort: (val) => {
return Buffer.from([val >> 8, val & 0xFF]); return Buffer.from([val >> 8, val & 0xff]);
}, },
/** /**
* Concatenates multiple byte buffers into a single byte buffer. * Concatenates multiple byte buffers into a single byte buffer.
* @param {Buffer[]} chunks - An array of byte buffers to concatenate. * @param {Buffer[]} chunks - An array of byte buffers to concatenate.
* @returns {Buffer} * @returns {Buffer}
*/ */
concat: (chunks) => { concat: (chunks) => {
let length = 0; let length = 0;
for (const chunk of chunks) { for (const chunk of chunks) {
length += chunk.length; length += chunk.length;
} }
const buffer = [ const buffer = [varint.encodeInt(length), ...chunks];
varint.encodeInt(length),
...chunks
];
return Buffer.concat(buffer); return Buffer.concat(buffer);
}, },
/** /**
* Decodes a varint integer value from a byte buffer. * Decodes a varint integer value from a byte buffer.
* @param {Buffer} buffer - The byte buffer to decode from. * @param {Buffer} buffer - The byte buffer to decode from.
* @param {number} offset - The offset in the buffer to start decoding from. * @param {number} offset - The offset in the buffer to start decoding from.
* @returns {number} * @returns {number}
*/ */
decodeInt: (buffer, offset) => { decodeInt: (buffer, offset) => {
let val = 0; let val = 0;
let count = 0; let count = 0;
while (true) { while (true) {
const byte = buffer.readUInt8(offset++); const byte = buffer.readUInt8(offset++);
val |= (byte & 0x7F) << count++ * 7; val |= (byte & 0x7f) << (count++ * 7);
if ((byte & 0x80) !== 0x80) { if ((byte & 0x80) !== 0x80) {
break; break;
} }
} }
return val; return val;
}, },
/** /**
* Calculates the number of bytes required to decode a varint integer value. * Calculates the number of bytes required to decode a varint integer value.
* @param {number} val - The varint integer value. * @param {number} val - The varint integer value.
* @returns {5 | 7 | 8 | 1 | 2 | 3 | 4 | 6 | 9 | 10} * @returns {5 | 7 | 8 | 1 | 2 | 3 | 4 | 6 | 9 | 10}
*/ */
decodeLength: (val) => { decodeLength: (val) => {
// Constants representing the powers of 2 used for comparison // Constants representing the powers of 2 used for comparison
const N1 = Math.pow(2, 7); const N1 = Math.pow(2, 7);
const N2 = Math.pow(2, 14); const N2 = Math.pow(2, 14);
const N3 = Math.pow(2, 21); const N3 = Math.pow(2, 21);
const N4 = Math.pow(2, 28); const N4 = Math.pow(2, 28);
const N5 = Math.pow(2, 35); const N5 = Math.pow(2, 35);
const N6 = Math.pow(2, 42); const N6 = Math.pow(2, 42);
const N7 = Math.pow(2, 49); const N7 = Math.pow(2, 49);
const N8 = Math.pow(2, 56); const N8 = Math.pow(2, 56);
const N9 = Math.pow(2, 63); const N9 = Math.pow(2, 63);
// Return the number of bytes required based on the value // Return the number of bytes required based on the value
return ( return val < N1
val < N1 ? 1 ? 1
: val < N2 ? 2 : val < N2
: val < N3 ? 3 ? 2
: val < N4 ? 4 : val < N3
: val < N5 ? 5 ? 3
: val < N6 ? 6 : val < N4
: val < N7 ? 7 ? 4
: val < N8 ? 8 : val < N5
: val < N9 ? 9 ? 5
: 10 : val < N6
); ? 6
} : val < N7
? 7
: val < N8
? 8
: val < N9
? 9
: 10;
},
}; };
export default varint; export default varint;

62
types/lib/java.d.ts vendored
View File

@ -4,49 +4,49 @@
* @param protocolVersion The protocol version. * @param protocolVersion The protocol version.
*/ */
export type JavaPingOptions = { export type JavaPingOptions = {
port?: number | undefined, port?: number | undefined;
timeout?: number | undefined, timeout?: number | undefined;
protocolVersion?: number | undefined; protocolVersion?: number | undefined;
}; };
/** /**
* JSON format chat component used for description field. * JSON format chat component used for description field.
* @see https://wiki.vg/Chat * @see https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Chat
*/ */
export type ChatComponent = { export type ChatComponent = {
text: string; text: string;
bold?: boolean; bold?: boolean;
italic?: boolean; italic?: boolean;
underlined?: boolean; underlined?: boolean;
strikethrough?: boolean; strikethrough?: boolean;
obfuscated?: boolean; obfuscated?: boolean;
color?: string; color?: string;
extra?: ChatComponent[]; extra?: ChatComponent[];
}; };
export type SampleProp = { export type SampleProp = {
name: string, name: string;
id: string; id: string;
}; };
/** /**
* `JSON Response` field of Response packet. * `JSON Response` field of Response packet.
* @see https://wiki.vg/Server_List_Ping#Response * @see https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Server_List_Ping#Status_Response
*/ */
export type JavaPingResponse = { export type JavaPingResponse = {
version: { version: {
name: string; name: string;
protocol: number; protocol: number;
}; };
players: { players: {
max: number; max: number;
online: number; online: number;
sample?: SampleProp[]; sample?: SampleProp[];
}; };
description: string | ChatComponent; description: string | ChatComponent;
favicon?: string; favicon?: string;
enforcesSecureChat?: boolean; enforcesSecureChat?: boolean;
previewsChat?: boolean; previewsChat?: boolean;
}; };
/** /**
@ -76,5 +76,7 @@ export type JavaPingResponse = {
* ``` * ```
* @see [source](https://github.com/minescope/mineping/blob/915edbec9c9ad811459458600af3531ec0836911/lib/java.js#L117) * @see [source](https://github.com/minescope/mineping/blob/915edbec9c9ad811459458600af3531ec0836911/lib/java.js#L117)
*/ */
export function pingJava(host: string, options?: JavaPingOptions): Promise<JavaPingResponse>; export function pingJava(
host: string,
options?: JavaPingOptions
): Promise<JavaPingResponse>;