2022-01-10 20:21:47 +00:00
|
|
|
/**
|
|
|
|
* Implementation of the Java Minecraft ping protocol.
|
|
|
|
* @see https://wiki.vg/Server_List_Ping
|
|
|
|
*/
|
|
|
|
|
|
|
|
'use strict';
|
|
|
|
|
2024-10-09 18:59:16 +00:00
|
|
|
import net from 'node:net';
|
2022-01-10 20:21:47 +00:00
|
|
|
import varint from './varint.js';
|
|
|
|
|
2023-10-22 18:32:00 +00:00
|
|
|
/**
|
|
|
|
* Ping a Minecraft Java server.
|
|
|
|
* @param {string} host The host of the Java server.
|
|
|
|
* @param {number} [port=25565] The port of the Java server.
|
|
|
|
* @param {function} cb The callback function to handle the ping response.
|
|
|
|
* @param {number} [timeout=5000] The timeout duration in milliseconds.
|
2023-12-08 11:26:10 +00:00
|
|
|
* @param {number} [protocolVersion=-1] The protocol version of the Java client.
|
2023-10-22 18:32:00 +00:00
|
|
|
*/
|
2023-12-08 11:26:10 +00:00
|
|
|
function ping(host, port = 25565, cb, timeout = 5000, protocolVersion = -1) {
|
2022-01-10 20:21:47 +00:00
|
|
|
const socket = net.createConnection(({ host, port }));
|
|
|
|
|
|
|
|
// Set manual timeout interval.
|
|
|
|
// This ensures the connection will NEVER hang regardless of internal state
|
|
|
|
const timeoutTask = setTimeout(() => {
|
|
|
|
socket.emit('error', new Error('Socket timeout'));
|
|
|
|
}, timeout);
|
|
|
|
|
|
|
|
const closeSocket = () => {
|
|
|
|
socket.destroy();
|
|
|
|
clearTimeout(timeoutTask);
|
|
|
|
};
|
|
|
|
|
|
|
|
// Generic error handler
|
|
|
|
// This protects multiple error callbacks given the complex socket state
|
|
|
|
// This is mostly dangerous since it can swallow errors
|
|
|
|
let didFireError = false;
|
|
|
|
|
2023-10-22 18:32:00 +00:00
|
|
|
/**
|
|
|
|
* Handle any error that occurs during the ping process.
|
|
|
|
* @param {Error} err The error that occurred.
|
|
|
|
*/
|
2022-01-10 20:21:47 +00:00
|
|
|
const handleError = (err) => {
|
|
|
|
closeSocket();
|
|
|
|
|
|
|
|
if (!didFireError) {
|
|
|
|
didFireError = true;
|
|
|
|
cb(null, err);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// #setNoDelay instantly flushes data during read/writes
|
|
|
|
// This prevents the runtime from delaying the write at all
|
|
|
|
socket.setNoDelay(true);
|
|
|
|
|
|
|
|
socket.on('connect', () => {
|
|
|
|
const handshake = varint.concat([
|
|
|
|
varint.encodeInt(0),
|
2023-12-08 11:26:10 +00:00
|
|
|
varint.encodeInt(protocolVersion),
|
2022-01-10 20:21:47 +00:00
|
|
|
varint.encodeInt(host.length),
|
|
|
|
varint.encodeString(host),
|
|
|
|
varint.encodeUShort(port),
|
|
|
|
varint.encodeInt(1)
|
|
|
|
]);
|
|
|
|
|
|
|
|
socket.write(handshake);
|
|
|
|
|
|
|
|
const request = varint.concat([
|
|
|
|
varint.encodeInt(0)
|
|
|
|
]);
|
|
|
|
|
|
|
|
socket.write(request);
|
|
|
|
});
|
|
|
|
|
|
|
|
let incomingBuffer = Buffer.alloc(0);
|
|
|
|
|
|
|
|
socket.on('data', (data) => {
|
|
|
|
incomingBuffer = Buffer.concat([incomingBuffer, data]);
|
2023-10-22 18:32:00 +00:00
|
|
|
|
2022-01-10 20:21:47 +00:00
|
|
|
// 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
|
|
|
|
// "VarInts are never longer than 5 bytes"
|
|
|
|
// https://wiki.vg/Data_types#VarInt_and_VarLong
|
|
|
|
if (incomingBuffer.length < 5) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
let offset = 0;
|
|
|
|
const packetLength = varint.decodeInt(incomingBuffer, offset);
|
|
|
|
|
|
|
|
// Ensure incomingBuffer contains the full response
|
|
|
|
if (incomingBuffer.length - offset < packetLength) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const packetId = varint.decodeInt(incomingBuffer, varint.decodeLength(packetLength));
|
|
|
|
|
|
|
|
if (packetId === 0) {
|
2023-10-22 18:32:00 +00:00
|
|
|
const data = incomingBuffer.subarray(varint.decodeLength(packetLength) + varint.decodeLength(packetId));
|
2022-01-10 20:21:47 +00:00
|
|
|
const responseLength = varint.decodeInt(data, 0);
|
2023-10-22 18:32:00 +00:00
|
|
|
const response = data.subarray(varint.decodeLength(responseLength), varint.decodeLength(responseLength) + responseLength);
|
2022-01-10 20:21:47 +00:00
|
|
|
|
|
|
|
try {
|
|
|
|
const message = JSON.parse(response);
|
|
|
|
|
|
|
|
closeSocket();
|
2023-10-22 18:32:00 +00:00
|
|
|
cb(message, null);
|
2022-01-10 20:21:47 +00:00
|
|
|
} catch (err) {
|
|
|
|
handleError(err);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
handleError(new Error('Received unexpected packet'));
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
socket.on('error', handleError);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Asynchronously ping Minecraft Java server.
|
2023-12-08 12:16:30 +00:00
|
|
|
* The optional `options` argument can be an object with a `port` (default is `25565`) or/and `timeout` (default is `5000`) or/and `protocolVersion` (default is `-1`) property.
|
2022-01-10 20:21:47 +00:00
|
|
|
* @param {string} host The Java server address.
|
|
|
|
* @param {import('../types/index.js').PingOptions} options The configuration for pinging Minecraft Java server.
|
2023-10-22 18:32:00 +00:00
|
|
|
* @returns {Promise<import('../types/index.js').JavaPingResponse>}
|
2022-01-10 20:21:47 +00:00
|
|
|
*/
|
|
|
|
export function pingJava(host, options = {}) {
|
|
|
|
if (!host) throw new Error('Host argument is not provided');
|
|
|
|
|
2023-12-08 11:26:10 +00:00
|
|
|
const { port = 25565, timeout = 5000, protocolVersion = -1 } = options;
|
2022-01-10 20:21:47 +00:00
|
|
|
|
|
|
|
return new Promise((resolve, reject) => {
|
2023-10-22 18:32:00 +00:00
|
|
|
ping(host, port, (res, err) => {
|
2022-01-10 20:21:47 +00:00
|
|
|
err ? reject(err) : resolve(res);
|
2023-12-08 11:26:10 +00:00
|
|
|
}, timeout, protocolVersion);
|
2022-01-10 20:21:47 +00:00
|
|
|
});
|
2023-12-08 11:26:10 +00:00
|
|
|
}
|