@quakejs/master 1.0.0

package/index.js

@@ -0,0 +1,5 @@
+import MasterClient from './master-client.js';
+import MasterServer from './master-server.js';
+
+export default { MasterClient, MasterServer };
+export { MasterClient, MasterServer };

package/master-base.js

@@ -0,0 +1,333 @@
+function generateChallenge () {
+  const CHALLENGE_CHARS = [
+    '!', '#', '$', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', '<', '=', '>', '?', '@',
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    '[', ']', '^', '_', '`',
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+    '{', '|', '}', '~'
+  ];
+  const CHALLENGE_MIN_LENGTH = 9;
+  const CHALLENGE_MAX_LENGTH = 12;
+
+  let challenge = '';
+  let length = CHALLENGE_MIN_LENGTH - 1;
+
+  length += parseInt(Math.random() * (CHALLENGE_MAX_LENGTH - CHALLENGE_MIN_LENGTH + 1), 10);
+
+  for (let i = 0; i < length; i++) {
+    challenge += CHALLENGE_CHARS[Math.floor(Math.random() * CHALLENGE_CHARS.length)];
+  }
+
+  return challenge;
+}
+
+function parseInfoString (str) {
+  const info = {};
+  let i = 0;
+
+  while (str.charAt(i) === '\\') {
+    const j = str.indexOf('\\', i + 1);
+    const k = str.indexOf('\\', j + 1);
+
+    if (j === -1) {
+      break;
+    }
+
+    const key = str.substring(i + 1, j);
+
+    if (k >= 0) {
+      info[key] = str.substring(j + 1, k);
+    } else {
+      info[key] = str.substring(j + 1);
+    }
+
+    i = j;
+  }
+
+  return info;
+}
+
+function formatInfoString (info) {
+  let str = '';
+
+  for (const [key, value] of Object.entries(info)) {
+    str += `\\${key}\\${value}`;
+  }
+
+  return str;
+}
+
+function parsePlayerString (str) {
+  let [score, ping, ...name] = str.split(' ');
+
+  name = name.join(' ');
+
+  return {
+    score: parseInt(score, 10),
+    ping: parseInt(ping, 10),
+    name: name.replace(/^"(.*)"$/, '$1')
+  };
+}
+
+function formatPlayerString (player) {
+  return `${player.score} ${player.ping} "${player.name}"`;
+}
+
+class Message {
+  get type () {
+    return this.constructor.id;
+  }
+}
+
+class Heartbeat extends Message {
+  static id = 'heartbeat';
+
+  constructor (from) {
+    super();
+
+    if (typeof from === 'string') {
+      this.game = from.substring(14).trim();
+    } else {
+      this.game = from?.game;
+    }
+  }
+
+  toString () {
+    return `${this.type}`;
+  }
+}
+
+class Subscribe extends Message {
+  static id = 'subscribe';
+
+  constructor (msg) {
+    super();
+  }
+
+  toString () {
+    return `${this.type}`;
+  }
+}
+
+class GetInfo extends Message {
+  static id = 'getinfo';
+
+  constructor (msg) {
+    super();
+
+    this.challenge = generateChallenge();
+  }
+
+  toString () {
+    return `${this.type} ${this.challenge}`;
+  }
+}
+
+class GetInfoResponse extends Message {
+  static id = 'infoResponse';
+
+  constructor (from) {
+    super();
+
+    if (typeof from === 'string') {
+      const infoString = from.substring(17);
+      this.info = parseInfoString(infoString);
+    } else {
+      this.info = from?.info;
+    }
+  }
+
+  toString () {
+    return `${this.type} ${formatInfoString(this.info)}`;
+  }
+}
+
+class GetStatus extends Message {
+  static id = 'getstatus';
+
+  constructor (msg) {
+    super();
+  }
+
+  toString () {
+    return `${this.type}`;
+  }
+}
+
+class GetStatusResponse extends Message {
+  static id = 'statusResponse';
+
+  constructor (from) {
+    super();
+
+    if (typeof from === 'string') {
+      const lines = from.split('\n').filter(x => x);
+
+      this.info = parseInfoString(lines[1]);
+      this.players = lines.slice(2).map(x => parsePlayerString(x));
+    } else {
+      this.info = from?.info;
+      this.players = from?.players;
+    }
+  }
+
+  toString () {
+    const lines = [
+      this.type,
+      formatInfoString(this.info),
+      ...this.players.map(x => formatPlayerString(x))
+    ];
+    return lines.join('\n');
+  }
+}
+
+class GetServers extends Message {
+  static id = 'getservers';
+
+  constructor (from) {
+    super();
+
+    if (typeof from === 'string') {
+      const fields = from.substring(15).split(' ').filter(x => x);
+
+      this.protocol = parseInt(fields[0], 10);
+      this.keywords = fields.slice(1);
+    } else {
+      this.protocol = from?.protocol;
+      this.keywords = from?.keywords;
+    }
+  }
+
+  toString () {
+    let str = `${this.type} ${this.protocol}`;
+
+    for (const keyword of this.keywords) {
+      str += ` ${keyword}`;
+    }
+
+    return str;
+  }
+}
+
+class GetServersResponse extends Message {
+  static id = 'getserversResponse';
+
+  constructor (from) {
+    super();
+
+    if (typeof from === 'string') {
+      this.servers = [];
+
+      for (let i = 23; i < from.length - 7; i += 7) {
+        const bytes = [
+          from.charCodeAt(i + 1),
+          from.charCodeAt(i + 2),
+          from.charCodeAt(i + 3),
+          from.charCodeAt(i + 4),
+          from.charCodeAt(i + 5),
+          from.charCodeAt(i + 6)
+        ];
+        const addr = `${bytes[0]}.${bytes[1]}.${bytes[2]}.${bytes[3]}`;
+        const port = (bytes[4] << 8) | bytes[5];
+
+        this.servers.push({ addr, port });
+      }
+    } else {
+      this.servers = from?.servers;
+    }
+  }
+
+  toString () {
+    let str = `${this.type} `;
+
+    for (const server of this.servers) {
+      const octets = server.addr.split('.').map(x => parseInt(x, 10));
+
+      str += '\\';
+      str += String.fromCharCode(octets[0] & 0xff);
+      str += String.fromCharCode(octets[1] & 0xff);
+      str += String.fromCharCode(octets[2] & 0xff);
+      str += String.fromCharCode(octets[3] & 0xff);
+      str += String.fromCharCode((server.port & 0xff00) >> 8);
+      str += String.fromCharCode((server.port & 0x00ff) >> 0);
+    }
+
+    str += '\\EOT';
+
+    return str;
+  }
+}
+
+class MasterBase {
+  static #messages = new Map([
+    [Heartbeat.id, Heartbeat],
+    [Subscribe.id, Subscribe],
+    [GetInfo.id, GetInfo],
+    [GetInfoResponse.id, GetInfoResponse],
+    [GetStatus.id, GetStatus],
+    [GetStatusResponse.id, GetStatusResponse],
+    [GetServers.id, GetServers],
+    [GetServersResponse.id, GetServersResponse]
+  ]);
+
+  encode (id, opts) {
+    const MessageCtor = MasterBase.#messages.get(id);
+
+    if (!MessageCtor) {
+      return null;
+    }
+
+    const msg = new MessageCtor(opts);
+    const str = `\xff\xff\xff\xff${msg.toString()}`;
+
+    return Uint8Array.from(str, x => x.charCodeAt(0));
+  }
+
+  decode (buffer) {
+    let str;
+    let i;
+
+    if (typeof buffer === 'string') {
+      str = buffer;
+    } else {
+      str = String.fromCharCode.apply(null, buffer);
+    }
+
+    if (!str.startsWith('\xff\xff\xff\xff')) {
+      return null;
+    }
+
+    for (i = 4; i < str.length; i++) {
+      const c = str.charCodeAt(i);
+
+      if ((c < 65 || c > 90) && (c < 97 || c > 122)) {
+        break;
+      }
+    }
+
+    const id = str.substring(4, i);
+    const MessageCtor = MasterBase.#messages.get(id);
+
+    if (!MessageCtor) {
+      return null;
+    }
+
+    return new MessageCtor(str);
+  }
+
+  pretty (msg) {
+    let out = '';
+
+    for (let i = 0; i < msg.length; i++) {
+      if (msg[i] >= 32 && msg[i] <= 126) {
+        out += String.fromCharCode(msg[i]);
+      } else {
+        out += `\\x${msg[i].toString(16).padStart(2, '0')}`;
+      }
+    }
+
+    return out;
+  }
+}
+
+export default MasterBase;

package/master-client.js

@@ -0,0 +1,155 @@
+import MasterBase from './master-base.js';
+
+class MasterClient extends MasterBase {
+  #onserver;
+  #master;
+
+  constructor (onserver) {
+    super();
+
+    this.#onserver = onserver;
+    this.#master = null;
+  }
+
+  subscribe (host, port) {
+    let resendTimeout;
+
+    if (this.#master) {
+      this.#master.close();
+      this.#master = null;
+    }
+
+    this.#master = new WebTransport(`${host}:${port}`);
+
+    const writer = this.#master.datagrams.writable.getWriter();
+    const reader = this.#master.datagrams.readable.getReader();
+
+    this.#master.ready.then(async () => {
+      while (true) {
+        const { done, value } = await reader.read();
+
+        clearTimeout(resendTimeout);
+
+        if (done) {
+          break;
+        }
+
+        console.log(`${host}:${port} ---> ${this.pretty(value)}`);
+
+        const msg = this.decode(value);
+
+        if (msg && msg.type === 'getserversResponse') {
+          for (const server of msg.servers) {
+            this.#onserver(server.addr, server.port);
+          }
+        }
+      }
+    }).catch((e) => {
+      console.error(`Stream error, connection to ${host}:${port} lost`, e);
+    });
+
+    this.#master.closed.catch((e) => {
+      console.error(`Stream error, connection to ${host}:${port} lost`, e);
+      this.#master = null;
+    });
+
+    /* send until a response is received */
+    const send = () => {
+      writer.write(this.encode('subscribe'));
+
+      resendTimeout = setTimeout(send, 1000);
+    };
+
+    send();
+  }
+
+  async getinfo (addr, port) {
+    const session = new WebTransport(`https://${addr}:${port}`);
+    const writer = session.datagrams.writable.getWriter();
+    const reader = session.datagrams.readable.getReader();
+    let resendTimeout;
+    let begin;
+
+    await session.ready;
+
+    /* send request multiple times until something is read back */
+    const send = () => {
+      begin = performance.now();
+
+      writer.write(this.encode('getinfo'));
+
+      resendTimeout = setTimeout(send, 3000);
+    };
+
+    send();
+
+    /* read response */
+    const { done, value } = await reader.read();
+
+    clearTimeout(resendTimeout);
+
+    if (done) {
+      throw new Error('getinfo failed, no response received');
+    }
+
+    console.log(`${addr}:${port} ---> ${this.pretty(value)}`);
+
+    const msg = this.decode(value);
+
+    if (!msg || msg.type !== 'infoResponse') {
+      throw new Error('getinfo failed, didn\'t receive infoResponse');
+    }
+
+    msg.info.ping = Math.min((performance.now() - begin) >>> 0, 999);
+
+    session.close();
+
+    return msg.info;
+  }
+
+  async getstatus (addr, port) {
+    const session = new WebTransport(`https://${addr}:${port}`);
+    const writer = session.datagrams.writable.getWriter();
+    const reader = session.datagrams.readable.getReader();
+    let resendTimeout;
+    let begin;
+
+    await session.ready;
+
+    /* send request multiple times until something is read back */
+    const send = () => {
+      begin = performance.now();
+
+      writer.write(this.encode('getstatus'));
+
+      resendTimeout = setTimeout(send, 3000);
+    };
+
+    send();
+
+    /* read response */
+    const { done, value } = await reader.read();
+
+    clearTimeout(resendTimeout);
+
+    if (done) {
+      throw new Error('getstatus failed, no response received');
+    }
+
+    console.log(`${addr}:${port} ---> ${this.pretty(value)}`);
+
+    const msg = this.decode(value);
+
+    if (!msg || msg.type !== 'statusResponse') {
+      throw new Error('getstatus failed, didn\'t receive statusResponse');
+    }
+
+    msg.info.ping = Math.min((performance.now() - begin) >>> 0, 999);
+
+    session.close();
+
+    return { info: msg.info, players: msg.players };
+  }
+}
+
+export default MasterClient;

package/master-server.js

@@ -0,0 +1,228 @@
+import { Http3Server } from '@fails-components/webtransport';
+
+import MasterBase from './master-base.js';
+
+class MasterServer extends MasterBase {
+  static #SERVER_PRUNE_INTERVAL = 350 * 1000;
+
+  #pruneInterval;
+  #listening;
+  #clients;
+  #servers;
+  #h3;
+
+  constructor (opts) {
+    super();
+
+    this.#pruneInterval = 0;
+    this.#listening = false;
+    this.#clients = [];
+    this.#servers = {};
+    this.#h3 = new Http3Server(opts);
+  }
+
+  #removeClient (session) {
+    const idx = this.#clients.indexOf(session);
+
+    if (idx === -1) {
+      return false;
+    }
+
+    this.#clients.splice(idx, 1);
+
+    return true;
+  }
+
+  #addClient (session) {
+    const idx = this.#clients.indexOf(session);
+
+    if (idx !== -1) {
+      return false;
+    }
+
+    this.#clients.push(session);
+
+    return true;
+  }
+
+  #updateServer (addr, port, info) {
+    const id = `${addr}:${port}`;
+    let server = this.#servers[id];
+
+    if (!server) {
+      server = this.#servers[id] = { addr, port };
+    }
+
+    /* FIXME does anything use info... */
+    server.lastUpdate = Date.now();
+    server.info = info;
+
+    /* send partial update to all clients */
+    for (const client of this.#clients) {
+      this.#sendServers(client, [server]);
+    }
+  }
+
+  #removeServer (id) {
+    delete this.#servers[id];
+
+    console.log(`${id} timed out, ${Object.keys(this.#servers).length} server(s) currently registered`);
+  }
+
+  #pruneServers () {
+    const now = Date.now();
+
+    for (const [id, server] of Object.entries(this.#servers)) {
+      const delta = now - server.lastUpdate;
+
+      if (delta > MasterServer.#SERVER_PRUNE_INTERVAL) {
+        this.#removeServer(id);
+      }
+    }
+  }
+
+  #sendServers (session, servers) {
+    const msg = this.encode('getserversResponse', { servers });
+
+    console.log(`${session.addr}:${session.port} <--- ${this.pretty(msg)}`);
+
+    session.write(msg);
+  }
+
+  #handleInfoResponse (session, info) {
+    if (info.challenge !== session.lastChallenge) {
+      console.error(`Invalid challenge ${info.challenge}, expected ${session.lastChallenge}`);
+      return;
+    }
+
+    this.#updateServer(session.addr, session.port, info);
+  }
+
+  #handleGetServers (session, req) {
+    /* FIXME honor req.protocol and req.keywords */
+    this.#sendServers(session, Object.values(this.#servers));
+  }
+
+  #handleSubscribe (session) {
+    if (!this.#addClient(session)) {
+      return;
+    }
+
+    /* send all servers upon subscribing */
+    this.#sendServers(session, Object.values(this.#servers));
+  }
+
+  #handleHeartbeat (session, game) {
+    if (game !== 'QuakeArena-1') {
+      console.log(`Invalid game ${game}, expected QuakeArena-1`);
+      return;
+    }
+
+    const msg = this.encode('getinfo');
+
+    console.log(`${session.addr}:${session.port} <--- ${this.pretty(msg)}`);
+
+    session.lastChallenge = msg.challenge;
+
+    session.write(msg);
+  }
+
+  #handleEmscriptenPort (session, data) {
+    session.port = parseInt(data, 10);
+  }
+
+  listen () {
+    if (this.#listening) {
+      return;
+    }
+
+    this.#h3.ready.then(async () => {
+      const sessionStream = await this.#h3.sessionStream('/');
+      const sessionReader = sessionStream.getReader();
+
+      console.log(`listening on ${this.#h3.host}:${this.#h3.port}`);
+
+      while (true) {
+        const { done, value } = await sessionReader.read();
+        const session = value;
+
+        if (done) {
+          break;
+        }
+
+        session.ready.then(async () => {
+          const writer = session.datagrams.createWritable().getWriter();
+          const reader = session.datagrams.readable.getReader();
+          const [addr, port] = session.peerAddress.split(':');
+          let first = true;
+
+          session.addr = addr;
+          session.port = port;
+
+          session.write = (data) => {
+            writer.write(data);
+          };
+
+          while (true) {
+            const { done, value } = await reader.read();
+
+            if (done) {
+              return;
+            }
+
+            console.log(`${session.addr}:${session.port} ---> ${this.pretty(value)}`);
+
+            if (first) {
+              const str = String.fromCharCode.apply(null, value);
+
+              first = false;
+
+              if (str.startsWith('\xff\xff\xff\xffport')) {
+                this.#handleEmscriptenPort(session, str.substr(9));
+                continue;
+              }
+            }
+
+            const msg = this.decode(value);
+
+            switch (msg?.type) {
+              case 'heartbeat':
+                this.#handleHeartbeat(session, msg);
+                break;
+              case 'subscribe':
+                this.#handleSubscribe(session, msg);
+                break;
+              case 'getservers':
+                this.#handleGetServers(session, msg);
+                break;
+              case 'getinfoResponse':
+                this.#handleInfoResponse(session, msg);
+                break;
+              default:
+                console.error('invalid message');
+                break;
+            }
+          }
+        }).catch((e) => {
+          console.error(`Stream error, peer ${session.addr}:${session.port}`, e);
+        });
+
+        session.closed.catch((e) => {
+          console.error(`Stream error, peer ${session.addr}:${session.port}`, e);
+        }).finally(() => {
+          this.#removeClient(session);
+        });
+      }
+    }).catch((e) => {
+      console.error(e);
+    });
+
+    this.#h3.startServer();
+
+    this.#pruneInterval = setInterval(this.#pruneServers.bind(this), MasterServer.#SERVER_PRUNE_INTERVAL);
+
+    this.#listening = true;
+  }
+}
+
+export default MasterServer;

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@quakejs/master",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "bin": "server.js",
+  "dependencies": {
+    "@fails-components/webtransport": "^1.5.1",
+    "@fails-components/webtransport-transport-http3-quiche": "^1.5.1"
+  }
+}

package/server.js

@@ -0,0 +1,54 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import util from 'node:util';
+
+import MasterServer from './master-server.js';
+
+let args;
+
+try {
+  args = util.parseArgs({
+    options: {
+      help: { type: 'boolean' },
+      cert: { type: 'string' },
+      key: { type: 'string' },
+      port: { type: 'string', default: '27950' }
+    }
+  });
+
+  if (args.values.help) {
+    throw new Error();
+  }
+
+  if (!args.values.cert) {
+    throw new Error('Missing required argument --cert');
+  }
+
+  if (!args.values.key) {
+    throw new Error('Missing required argument --key');
+  }
+} catch (e) {
+  console.error('Usage: master.js --cert <cert.pem> --key <key.pem> [--port <num>]');
+
+  if (e.message) {
+    console.error();
+    console.error(e.message);
+  }
+
+  process.exit(1);
+}
+
+const port = parseInt(args.values.port);
+const cert = await fs.readFile(args.values.cert);
+const key = await fs.readFile(args.values.key);
+const secret = crypto.randomBytes(16).toString('hex');
+
+const server = new MasterServer({
+  host: '0.0.0.0',
+  port,
+  secret,
+  cert,
+  privKey: key
+});
+
+server.listen();