gamedigz 0.1.0

package/bin/gamedig.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+import * as process from "node:process";
+
+import Minimist from 'minimist'
+import { GameDig } from './../lib/index.js'
+
+const argv = Minimist(process.argv.slice(2), {
+  boolean: ['pretty', 'debug', 'givenPortOnly', 'requestRules', 'requestRulesRequired', 'requestPlayersRequired'],
+  string: ['guildId', 'listenUdpPort', 'ipFamily']
+})
+
+const debug = argv.debug
+delete argv.debug
+const pretty = !!argv.pretty || debug
+delete argv.pretty
+const givenPortOnly = argv.givenPortOnly
+delete argv.givenPortOnly
+const requestRulesRequired = argv.requestRulesRequired
+delete argv.requestRulesRequired
+const requestPlayersRequired = argv.requestPlayersRequired
+delete argv.requestPlayersRequired
+
+const options = {}
+for (const key of Object.keys(argv)) {
+  const value = argv[key]
+
+  if (key === '_' || key.charAt(0) === '$') { continue }
+
+  options[key] = value
+}
+
+if (argv._.length >= 1) {
+  const target = argv._[0]
+  const split = target.split(':')
+  options.host = split[0]
+  if (split.length >= 2) {
+    options.port = split[1]
+  }
+}
+if (debug) {
+  options.debug = true
+}
+if (givenPortOnly) {
+  options.givenPortOnly = true
+}
+if (requestRulesRequired) {
+  options.requestRulesRequired = true
+}
+if (requestPlayersRequired) {
+  options.requestPlayersRequired = true
+}
+
+const printOnPretty = (object) => {
+  if (pretty) {
+    console.log(JSON.stringify(object, null, '  '))
+  } else {
+    console.log(JSON.stringify(object))
+  }
+}
+
+const gamedig = new GameDig(options)
+gamedig.query(options)
+  .then(printOnPretty)
+  .catch((error) => {
+    if (debug) {
+      if (error instanceof Error) {
+        console.log(error.stack)
+      } else {
+        console.log(error)
+      }
+    } else {
+      if (error instanceof Error) {
+        error = error.message
+      }
+
+      printOnPretty({ error })
+    }
+  })

package/lib/DnsResolver.js

@@ -0,0 +1,76 @@
+import dns from 'node:dns'
+import { isIP } from 'node:net'
+import punycode from 'punycode/punycode.js'
+
+export default class DnsResolver {
+  /**
+     * @param {Logger} logger
+     */
+  constructor (logger) {
+    this.logger = logger
+  }
+
+  /**
+     * Resolve a host name to its IP, if the given host name is already
+     * an IP address no request is made.
+     *
+     * If a srvRecordPrefix is provided a SRV request will be made and the
+     * port returned will be included in the output.
+     * @param {string} host
+     * @param {number} ipFamily
+     * @param {string=} srvRecordPrefix
+     * @returns {Promise<{address:string, port:number=}>}
+     */
+  async resolve (host, ipFamily, srvRecordPrefix) {
+    this.logger.debug('DNS Lookup: ' + host)
+
+    // Check if host is IPv4 or IPv6
+    if (isIP(host) === 4 || isIP(host) === 6) {
+      this.logger.debug('Raw IP Address: ' + host)
+      return { address: host }
+    }
+
+    const asciiForm = punycode.toASCII(host)
+    if (asciiForm !== host) {
+      this.logger.debug('Encoded punycode: ' + host + ' -> ' + asciiForm)
+      host = asciiForm
+    }
+
+    if (srvRecordPrefix) {
+      this.logger.debug('SRV Resolve: ' + srvRecordPrefix + '.' + host)
+      let records
+      try {
+        records = await dns.promises.resolve(srvRecordPrefix + '.' + host, 'SRV')
+        if (records.length >= 1) {
+          this.logger.debug('Found SRV Records: ', records)
+          const record = records[0]
+          const srvPort = record.port
+          const srvHost = record.name
+          if (srvHost === host) {
+            throw new Error('Loop in DNS SRV records')
+          }
+          return {
+            port: srvPort,
+            ...await this.resolve(srvHost, ipFamily, srvRecordPrefix)
+          }
+        }
+        this.logger.debug('No SRV Record')
+      } catch (e) {
+        this.logger.debug(e)
+      }
+    }
+
+    this.logger.debug('Standard Resolve: ' + host)
+    const dnsResult = await dns.promises.lookup(host, ipFamily)
+    // For some reason, this sometimes returns a string address rather than an object.
+    // I haven't been able to reproduce, but it's been reported on the issue tracker.
+    let address
+    if (typeof dnsResult === 'string') {
+      address = dnsResult
+    } else {
+      address = dnsResult.address
+    }
+    this.logger.debug('Found address: ' + address)
+    return { address }
+  }
+}

package/lib/GlobalUdpSocket.js

@@ -0,0 +1,69 @@
+import { createSocket } from 'node:dgram'
+import { debugDump } from './HexUtil.js'
+import { promisify } from 'node:util'
+import Logger from './Logger.js'
+
+export default class GlobalUdpSocket {
+  constructor ({ port }) {
+    this.socket = null
+    this.callbacks = new Set()
+    this.debuggingCallbacks = new Set()
+    this.logger = new Logger()
+    this.port = port
+  }
+
+  async _getSocket () {
+    if (!this.socket) {
+      const udpSocket = createSocket({
+        type: 'udp4',
+        reuseAddr: true
+      })
+      udpSocket.unref()
+      udpSocket.on('message', (buffer, rinfo) => {
+        const fromAddress = rinfo.address
+        const fromPort = rinfo.port
+        this.logger.debug(log => {
+          log(fromAddress + ':' + fromPort + ' <--UDP(' + this.port + ')')
+          log(debugDump(buffer))
+        })
+        for (const callback of this.callbacks) {
+          callback(fromAddress, fromPort, buffer)
+        }
+      })
+      udpSocket.on('error', e => {
+        this.logger.debug('UDP ERROR:', e)
+      })
+      await promisify(udpSocket.bind).bind(udpSocket)(this.port)
+      this.port = udpSocket.address().port
+      this.socket = udpSocket
+    }
+    return this.socket
+  }
+
+  async send (buffer, address, port, debug) {
+    const socket = await this._getSocket()
+
+    if (debug) {
+      this.logger._print(log => {
+        log(address + ':' + port + ' UDP(' + this.port + ')-->')
+        log(debugDump(buffer))
+      })
+    }
+
+    await promisify(socket.send).bind(socket)(buffer, 0, buffer.length, port, address)
+  }
+
+  addCallback (callback, debug) {
+    this.callbacks.add(callback)
+    if (debug) {
+      this.debuggingCallbacks.add(callback)
+      this.logger.debugEnabled = true
+    }
+  }
+
+  removeCallback (callback) {
+    this.callbacks.delete(callback)
+    this.debuggingCallbacks.delete(callback)
+    this.logger.debugEnabled = this.debuggingCallbacks.size > 0
+  }
+}

package/lib/HexUtil.js

@@ -0,0 +1,20 @@
+/** @param {Buffer} buffer */
+export const debugDump = (buffer) => {
+  let hexLine = ''
+  let chrLine = ''
+  let out = ''
+  out += 'Buffer length: ' + buffer.length + ' bytes\n'
+  for (let i = 0; i < buffer.length; i++) {
+    const sliced = buffer.slice(i, i + 1)
+    hexLine += sliced.toString('hex') + ' '
+    let chr = sliced.toString()
+    if (chr < ' ' || chr > '~') chr = ' '
+    chrLine += chr + '  '
+    if (hexLine.length > 60 || i === buffer.length - 1) {
+      out += hexLine + '\n'
+      out += chrLine + '\n'
+      hexLine = chrLine = ''
+    }
+  }
+  return out
+}

package/lib/Logger.js

@@ -0,0 +1,45 @@
+import { debugDump } from './HexUtil.js'
+import { Buffer} from 'node:buffer'
+
+export default class Logger {
+  constructor () {
+    this.debugEnabled = false
+    this.prefix = ''
+  }
+
+  debug (...args) {
+    if (!this.debugEnabled) return
+    this._print(...args)
+  }
+
+  _print (...args) {
+    try {
+      const strings = this._convertArgsToStrings(...args)
+      if (strings.length) {
+        if (this.prefix) {
+          strings.unshift(this.prefix)
+        }
+        console.log(...strings)
+      }
+    } catch (e) {
+      console.log('Error while logging: ' + e)
+    }
+  }
+
+  _convertArgsToStrings (...args) {
+    const out = []
+    for (const arg of args) {
+      if (arg instanceof Error) {
+        out.push(arg.stack)
+      } else if (arg instanceof Buffer) {
+        out.push(debugDump(arg))
+      } else if (typeof arg === 'function') {
+        const result = arg.call(undefined, (...args) => this._print(...args))
+        if (result !== undefined) out.push(...this._convertArgsToStrings(result))
+      } else {
+        out.push(arg)
+      }
+    }
+    return out
+  }
+}

package/lib/Promises.js

@@ -0,0 +1,18 @@
+export default class Promises {
+  static createTimeout (timeoutMs, timeoutMsg) {
+    let cancel = null
+    const wrapped = new Promise((resolve, reject) => {
+      const timeout = setTimeout(
+        () => {
+          reject(new Error(timeoutMsg + ' - Timed out after ' + timeoutMs + 'ms'))
+        },
+        timeoutMs
+      )
+      cancel = () => {
+        clearTimeout(timeout)
+      }
+    })
+    wrapped.cancel = cancel
+    return wrapped
+  }
+}

package/lib/ProtocolResolver.js

@@ -0,0 +1,7 @@
+import * as protocols from '../protocols/index.js'
+
+export const getProtocol = (protocolId) => {
+  if (!(protocolId in protocols)) { throw Error('Protocol definition file missing: ' + protocolId) }
+
+  return new protocols[protocolId]()
+}

package/lib/QueryRunner.js

@@ -0,0 +1,95 @@
+import { lookup } from './game-resolver.js'
+import { getProtocol } from './ProtocolResolver.js'
+import GlobalUdpSocket from './GlobalUdpSocket.js'
+
+const defaultOptions = {
+  socketTimeout: 2000,
+  attemptTimeout: 10000,
+  maxAttempts: 1,
+  ipFamily: 0
+}
+
+export default class QueryRunner {
+  constructor (runnerOpts = {}) {
+    this.udpSocket = new GlobalUdpSocket({
+      port: runnerOpts.listenUdpPort
+    })
+  }
+
+  async run (userOptions) {
+    for (const key of Object.keys(userOptions)) {
+      const value = userOptions[key]
+      if (['port', 'ipFamily'].includes(key)) {
+        userOptions[key] = parseInt(value)
+      }
+    }
+
+    const {
+      port_query: gameQueryPort,
+      port_query_offset: gameQueryPortOffset,
+      ...gameOptions
+    } = lookup(userOptions.type)
+    const attempts = []
+
+    const optionsCollection = {
+      ...defaultOptions,
+      ...gameOptions,
+      ...userOptions
+    }
+
+    const addAttemptWithPort = port => {
+      attempts.push({
+        ...optionsCollection,
+        port
+      })
+    }
+
+    if (userOptions.port) {
+      if (!userOptions.givenPortOnly) {
+        if (gameQueryPortOffset) { addAttemptWithPort(userOptions.port + gameQueryPortOffset) }
+
+        if (userOptions.port === gameOptions.port && gameQueryPort) { addAttemptWithPort(gameQueryPort) }
+      }
+
+      attempts.push(optionsCollection)
+    } else if (gameQueryPort) {
+      addAttemptWithPort(gameQueryPort)
+    } else if (gameOptions.port) {
+      addAttemptWithPort(gameOptions.port + (gameQueryPortOffset || 0))
+    } else {
+      // Hopefully the request doesn't need a port. If it does, it'll fail when making the request.
+      attempts.push(optionsCollection)
+    }
+
+    const numRetries = userOptions.maxAttempts || gameOptions.maxAttempts || defaultOptions.maxAttempts
+
+    let attemptNum = 0
+    const errors = []
+    for (const attempt of attempts) {
+      for (let retry = 0; retry < numRetries; retry++) {
+        attemptNum++
+
+        try {
+          return await this._attempt(attempt)
+        } catch (e) {
+          e.stack = 'Attempt #' + attemptNum + ' - Port=' + attempt.port + ' Retry=' + (retry) + ':\n' + e.stack
+          errors.push(e)
+        }
+      }
+    }
+
+    const err = new Error('Failed all ' + errors.length + ' attempts')
+    for (const e of errors) {
+      err.stack += '\n' + e.stack
+    }
+
+    throw err
+  }
+
+  async _attempt (options) {
+    const core = getProtocol(options.protocol)
+    core.options = options
+    core.udpSocket = this.udpSocket
+    return await core.runOnceSafe()
+  }
+}

package/lib/Results.js

@@ -0,0 +1,32 @@
+export class Player {
+  name = ''
+  raw = {}
+
+  constructor (data) {
+    if (typeof data === 'string') {
+      this.name = data
+    } else {
+      const { name, ...raw } = data
+      if (name) this.name = name
+      if (raw) this.raw = raw
+    }
+  }
+}
+
+export class Players extends Array {
+  push (data) {
+    super.push(new Player(data))
+  }
+}
+
+export class Results {
+  name = ''
+  map = ''
+  password = false
+
+  raw = {}
+
+  maxplayers = 0
+  players = new Players()
+  bots = new Players()
+}

package/lib/game-resolver.js

@@ -0,0 +1,17 @@
+import { games } from './games.js'
+
+export const lookup = (type) => {
+  if (!type) { throw Error('No game specified') }
+
+  if (type.startsWith('protocol-')) {
+    return {
+      protocol: type.substring(9)
+    }
+  }
+
+  const game = games[type]
+
+  if (!game) { throw Error('Invalid game: ' + type) }
+
+  return game.options
+}

package/lib/gamedig.js

@@ -0,0 +1,23 @@
+import QueryRunner from './QueryRunner.js'
+
+let singleton = null
+
+export class GameDig {
+  constructor (runnerOpts) {
+    this.queryRunner = new QueryRunner(runnerOpts)
+  }
+
+  async query (userOptions) {
+    return await this.queryRunner.run(userOptions)
+  }
+
+  static getInstance () {
+    if (!singleton) { singleton = new GameDig() }
+
+    return singleton
+  }
+
+  static async query (...args) {
+    return await GameDig.getInstance().query(...args)
+  }
+}