@serverkgg/bridge 0.0.13 → 0.0.15

package/src/rcon/rconIds.ts

@@ -0,0 +1,33 @@
+const FIRST_ID = 1;
+
+const LAST_ID = 2_147_483_646;
+
+export interface RconIdPair {
+	id: number;
+	probeId: number;
+}
+
+export interface RconIds {
+	next(): RconIdPair;
+}
+
+export const createRconIds = (seed = FIRST_ID): RconIds => {
+	let cursor = seed >= FIRST_ID && seed < LAST_ID ? seed : FIRST_ID;
+
+	return {
+		next() {
+			if (cursor + 1 > LAST_ID) {
+				cursor = FIRST_ID;
+			}
+
+			const pair = {
+				id: cursor,
+				probeId: cursor + 1,
+			};
+
+			cursor += 2;
+
+			return pair;
+		},
+	};
+};

package/src/rcon/rconLink.ts

@@ -0,0 +1,427 @@
+import type { Socket } from "bun";
+import { BridgeRconCode, BridgeRconError } from "../core";
+import { rconError, rconTarget } from "./rconError";
+import {
+	concatBytes,
+	decodeRconFrames,
+	encodeRconFrame,
+	RCON_AUTH_FAILED_ID,
+	RCON_REPLY_LIMIT,
+	RCON_SPLIT_THRESHOLD,
+	type RconDecodedFrame,
+	RconRequest,
+	RconResponse,
+} from "./rconFrame";
+import type { RconIds } from "./rconIds";
+import { createRconWriter, type RconWriter } from "./rconWriter";
+
+const CLOSE_GRACE_MS = 1000;
+
+const EMPTY = new Uint8Array(0);
+
+export interface RconLinkOptions {
+	host: string;
+	port: number;
+	password: string;
+	timeoutMs: number;
+	ids: RconIds;
+	onLost(error: BridgeRconError): void;
+}
+
+export interface RconExchange {
+	id: number;
+	probeId: number | null;
+	request: Uint8Array;
+	probe: Uint8Array | null;
+	mirroredIds: boolean;
+	deadlineAt: number;
+}
+
+export interface RconExchangeResult {
+	written: number;
+	reply: Promise<string>;
+}
+
+export interface RconLink {
+	readonly alive: boolean;
+	send(exchange: RconExchange): RconExchangeResult;
+	close(error: BridgeRconError): Promise<void>;
+}
+
+interface RconWaiting {
+	id: number;
+	probeId: number | null;
+	probe: Uint8Array | null;
+	probeSent: boolean;
+	mirroredIds: boolean;
+	auth: boolean;
+	parts: string[];
+	length: number;
+	settle(outcome: string | BridgeRconError): void;
+}
+
+export const openRconLink = async (options: RconLinkOptions): Promise<RconLink> => {
+	const target = rconTarget(options.host, options.port);
+	const deadlineAt = performance.now() + options.timeoutMs;
+
+	let alive = true;
+	let handed = false;
+	let expired = false;
+	let ended = false;
+	let buffer = EMPTY;
+	let socket: Socket<undefined> | null = null;
+	let writer: RconWriter | null = null;
+	let waiting: RconWaiting | null = null;
+	let exchangeTimer: ReturnType<typeof setTimeout> | undefined;
+	let graceTimer: ReturnType<typeof setTimeout> | undefined;
+	let releaseClosed = () => {};
+
+	const closed = new Promise<void>((resolve) => {
+		releaseClosed = resolve;
+	});
+
+	const settleWaiting = (outcome: string | BridgeRconError) => {
+		const current = waiting;
+
+		waiting = null;
+
+		clearTimeout(exchangeTimer);
+		current?.settle(outcome);
+	};
+
+	const endSocket = () => {
+		if (!socket || ended) {
+			releaseClosed();
+
+			return;
+		}
+
+		const current = socket;
+
+		ended = true;
+		current.end();
+
+		graceTimer = setTimeout(() => {
+			current.terminate();
+			releaseClosed();
+		}, CLOSE_GRACE_MS);
+	};
+
+	const drop = (error: BridgeRconError, notify: boolean) => {
+		if (!alive) {
+			return;
+		}
+
+		alive = false;
+
+		settleWaiting(error);
+		endSocket();
+
+		if (notify && handed) {
+			options.onLost(error);
+		}
+	};
+
+	const accept = (frame: RconDecodedFrame) => {
+		const current = waiting;
+
+		if (!current) {
+			return;
+		}
+
+		if (current.auth) {
+			if (frame.type !== RconResponse.Auth) {
+				return;
+			}
+
+			settleWaiting(
+				frame.id === RCON_AUTH_FAILED_ID
+					? new BridgeRconError(BridgeRconCode.AuthFailed, `${target} rejected the rcon password`)
+					: "",
+			);
+
+			return;
+		}
+
+		if (frame.type !== RconResponse.Value) {
+			return;
+		}
+
+		if (current.probeSent && frame.id === current.probeId) {
+			settleWaiting(current.parts.join(""));
+
+			return;
+		}
+
+		if (current.mirroredIds && frame.id !== current.id) {
+			return;
+		}
+
+		current.parts.push(frame.body);
+		current.length += frame.body.length;
+
+		if (current.length > RCON_REPLY_LIMIT) {
+			drop(
+				new BridgeRconError(
+					BridgeRconCode.Oversized,
+					`${target} sent an rcon reply larger than ${RCON_REPLY_LIMIT} bytes`,
+				),
+				true,
+			);
+
+			return;
+		}
+
+		const probe = current.probe;
+
+		if (!probe) {
+			settleWaiting(current.parts.join(""));
+
+			return;
+		}
+
+		if (current.probeSent) {
+			return;
+		}
+
+		if (frame.bodyBytes < RCON_SPLIT_THRESHOLD) {
+			settleWaiting(current.parts.join(""));
+
+			return;
+		}
+
+		current.probeSent = true;
+
+		const accepted = writer ? writer.send(probe) : 0;
+
+		if (accepted === 0 && (!writer || writer.dead)) {
+			drop(new BridgeRconError(BridgeRconCode.Closed, `the rcon probe to ${target} could not be sent`), true);
+		}
+	};
+
+	const receive = (chunk: Uint8Array) => {
+		let decoded: ReturnType<typeof decodeRconFrames>;
+
+		try {
+			decoded = decodeRconFrames(concatBytes(buffer, chunk));
+		} catch (error) {
+			drop(rconError(BridgeRconCode.Malformed, `${target} sent an unreadable rcon packet`, error), true);
+
+			return;
+		}
+
+		buffer = decoded.rest.length > 0 ? decoded.rest.slice() : EMPTY;
+
+		for (const frame of decoded.frames) {
+			if (!alive) {
+				return;
+			}
+
+			accept(frame);
+		}
+	};
+
+	const opened = await new Promise<Socket<undefined>>((resolve, reject) => {
+		const timer = setTimeout(
+			() => {
+				expired = true;
+				alive = false;
+
+				reject(new BridgeRconError(BridgeRconCode.TimedOut, `the rcon connection to ${target} timed out`));
+			},
+			Math.max(0, deadlineAt - performance.now()),
+		);
+
+		Bun.connect({
+			hostname: options.host,
+			port: options.port,
+			socket: {
+				binaryType: "uint8array",
+				data(_socket, chunk) {
+					if (alive) {
+						receive(chunk);
+					}
+				},
+				close() {
+					ended = true;
+
+					clearTimeout(graceTimer);
+					releaseClosed();
+					drop(
+						new BridgeRconError(
+							BridgeRconCode.Closed,
+							handed
+								? `${target} closed the rcon connection`
+								: `${target} closed the rcon connection during authentication`,
+						),
+						true,
+					);
+				},
+				error(_socket, error) {
+					drop(rconError(BridgeRconCode.Unreachable, `the rcon connection to ${target} failed`, error), true);
+				},
+				drain() {
+					writer?.drain();
+				},
+				connectError() {},
+			},
+		}).then(
+			(created) => {
+				clearTimeout(timer);
+
+				if (expired) {
+					created.terminate();
+
+					return;
+				}
+
+				resolve(created);
+			},
+			(error: unknown) => {
+				clearTimeout(timer);
+
+				if (expired) {
+					return;
+				}
+
+				reject(rconError(BridgeRconCode.Unreachable, `the rcon connection to ${target} could not be opened`, error));
+			},
+		);
+	});
+
+	socket = opened;
+
+	const sender = createRconWriter((bytes) => opened.write(bytes));
+
+	writer = sender;
+
+	const authId = options.ids.next().id;
+
+	try {
+		await new Promise<void>((resolve, reject) => {
+			if (!alive) {
+				reject(
+					new BridgeRconError(BridgeRconCode.Closed, `${target} closed the rcon connection during authentication`),
+				);
+
+				return;
+			}
+
+			waiting = {
+				id: authId,
+				probeId: null,
+				probe: null,
+				probeSent: false,
+				mirroredIds: true,
+				auth: true,
+				parts: [],
+				length: 0,
+				settle(outcome) {
+					if (outcome instanceof BridgeRconError) {
+						reject(outcome);
+
+						return;
+					}
+
+					resolve();
+				},
+			};
+
+			exchangeTimer = setTimeout(
+				() => {
+					drop(
+						new BridgeRconError(BridgeRconCode.TimedOut, `${target} did not answer the rcon authentication in time`),
+						false,
+					);
+				},
+				Math.max(0, deadlineAt - performance.now()),
+			);
+
+			const accepted = sender.send(
+				encodeRconFrame({
+					id: authId,
+					type: RconRequest.Auth,
+					body: options.password,
+				}),
+			);
+
+			if (accepted === 0 && sender.dead) {
+				drop(
+					new BridgeRconError(BridgeRconCode.Closed, `the rcon authentication with ${target} could not be sent`),
+					false,
+				);
+			}
+		});
+	} catch (error) {
+		drop(rconError(BridgeRconCode.Closed, `the rcon authentication with ${target} failed`, error), false);
+
+		throw error;
+	}
+
+	handed = true;
+
+	return {
+		get alive() {
+			return alive;
+		},
+
+		send(exchange) {
+			let written = 0;
+
+			const reply = new Promise<string>((resolve, reject) => {
+				if (!alive) {
+					reject(new BridgeRconError(BridgeRconCode.Closed, `${target} closed the rcon connection`));
+
+					return;
+				}
+
+				waiting = {
+					id: exchange.id,
+					probeId: exchange.probeId,
+					probe: exchange.probe,
+					probeSent: false,
+					mirroredIds: exchange.mirroredIds,
+					auth: false,
+					parts: [],
+					length: 0,
+					settle(outcome) {
+						if (outcome instanceof BridgeRconError) {
+							reject(outcome);
+
+							return;
+						}
+
+						resolve(outcome);
+					},
+				};
+
+				exchangeTimer = setTimeout(
+					() => {
+						drop(
+							new BridgeRconError(BridgeRconCode.TimedOut, `${target} did not answer the rcon request in time`),
+							true,
+						);
+					},
+					Math.max(0, exchange.deadlineAt - performance.now()),
+				);
+
+				written = sender.send(exchange.request);
+
+				if (written === 0 && sender.dead) {
+					drop(new BridgeRconError(BridgeRconCode.Closed, `the rcon request to ${target} could not be sent`), true);
+				}
+			});
+
+			return {
+				written,
+				reply,
+			};
+		},
+
+		async close(error) {
+			drop(error, false);
+
+			await closed;
+		},
+	};
+};

package/src/rcon/rconWriter.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "bun:test";
+import { createRconWriter } from "./rconWriter";
+
+const bytes = (...values: number[]) => new Uint8Array(values);
+
+const recorder = (accept: (writes: number) => number | null) => {
+	const writes: number[][] = [];
+
+	return {
+		writes,
+		write(chunk: Uint8Array) {
+			writes.push(Array.from(chunk));
+
+			return accept(writes.length) ?? chunk.length;
+		},
+	};
+};
+
+describe("createRconWriter", () => {
+	test("reports a full write and keeps nothing pending", () => {
+		const socket = recorder(() => null);
+		const writer = createRconWriter(socket.write);
+
+		expect(writer.send(bytes(1, 2, 3))).toBe(3);
+
+		writer.drain();
+
+		expect(socket.writes).toEqual([
+			[
+				1,
+				2,
+				3,
+			],
+		]);
+		expect(writer.dead).toBe(false);
+	});
+
+	test("buffers the remainder of a short write and finishes it on drain", () => {
+		const socket = recorder((writes) => (writes === 1 ? 2 : null));
+		const writer = createRconWriter(socket.write);
+
+		expect(writer.send(bytes(1, 2, 3, 4))).toBe(2);
+
+		writer.drain();
+
+		expect(socket.writes).toEqual([
+			[
+				1,
+				2,
+				3,
+				4,
+			],
+			[
+				3,
+				4,
+			],
+		]);
+	});
+
+	test("appends a send made while a remainder is pending", () => {
+		const socket = recorder((writes) => (writes === 1 ? 1 : null));
+		const writer = createRconWriter(socket.write);
+
+		writer.send(bytes(1, 2));
+
+		expect(writer.send(bytes(3, 4))).toBe(2);
+
+		writer.drain();
+
+		expect(socket.writes.at(1)).toEqual([
+			2,
+			3,
+			4,
+		]);
+	});
+
+	test("reports zero accepted and dies when the socket answers minus one", () => {
+		const socket = recorder(() => -1);
+		const writer = createRconWriter(socket.write);
+
+		expect(writer.send(bytes(1, 2))).toBe(0);
+		expect(writer.dead).toBe(true);
+		expect(writer.send(bytes(3))).toBe(0);
+		expect(socket.writes).toHaveLength(1);
+	});
+
+	test("does not write on a drain with an empty buffer", () => {
+		const socket = recorder(() => null);
+		const writer = createRconWriter(socket.write);
+
+		writer.drain();
+
+		expect(socket.writes).toHaveLength(0);
+	});
+});

package/src/rcon/rconWriter.ts

@@ -0,0 +1,63 @@
+import { concatBytes } from "./rconFrame";
+
+const EMPTY = new Uint8Array(0);
+
+export interface RconWriter {
+	readonly dead: boolean;
+	send(bytes: Uint8Array): number;
+	drain(): void;
+}
+
+export const createRconWriter = (write: (bytes: Uint8Array) => number): RconWriter => {
+	let pending: Uint8Array<ArrayBufferLike> = EMPTY;
+	let dead = false;
+
+	return {
+		get dead() {
+			return dead;
+		},
+
+		send(bytes) {
+			if (dead || bytes.length === 0) {
+				return 0;
+			}
+
+			if (pending.length > 0) {
+				pending = concatBytes(pending, bytes);
+
+				return bytes.length;
+			}
+
+			const written = write(bytes);
+
+			if (written < 0) {
+				dead = true;
+
+				return 0;
+			}
+
+			if (written < bytes.length) {
+				pending = bytes.slice(written);
+			}
+
+			return written;
+		},
+
+		drain() {
+			if (dead || pending.length === 0) {
+				return;
+			}
+
+			const written = write(pending);
+
+			if (written < 0) {
+				dead = true;
+				pending = EMPTY;
+
+				return;
+			}
+
+			pending = written < pending.length ? pending.slice(written) : EMPTY;
+		},
+	};
+};