game_dig 0.1.0 → 0.2.0

data/lib/game_dig/node/node_modules/gamedig/lib/DnsResolver.js

@@ -0,0 +1,80 @@
+import dns from 'node:dns'
+import { isIP } from 'node:net'
+import { domainToASCII } from 'node:url'
+
+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)) {
+      this.logger.debug('Raw IP Address: ' + host)
+      return { address: host }
+    }
+
+    const asciiForm = domainToASCII(host)
+    if (!asciiForm) {
+      throw new Error('Invalid domain')
+    }
+
+    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 }
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/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
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/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
+}

data/lib/game_dig/node/node_modules/gamedig/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
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/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
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/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]()
+}

data/lib/game_dig/node/node_modules/gamedig/lib/QueryRunner.js

@@ -0,0 +1,122 @@
+import { lookup } from './game-resolver.js'
+import { getProtocol } from './ProtocolResolver.js'
+import GlobalUdpSocket from './GlobalUdpSocket.js'
+
+const defaultOptions = {
+  socketTimeout: 2000,
+  attemptTimeout: 10000,
+  maxRetries: 1,
+  stripColors: true,
+  portCache: true,
+  noBreadthOrder: false,
+  ipFamily: 0,
+  requestPlayers: true
+}
+
+export default class QueryRunner {
+  constructor (runnerOpts = {}) {
+    this.udpSocket = new GlobalUdpSocket({
+      port: runnerOpts.listenUdpPort
+    })
+    this.portCache = {}
+  }
+
+  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)
+    const attempts = []
+
+    const optionsCollection = {
+      ...defaultOptions,
+      ...gameOptions,
+      ...userOptions
+    }
+
+    const addAttemptWithPort = port => {
+      attempts.push({
+        ...optionsCollection,
+        port
+      })
+    }
+
+    let portOffsetArray = gameQueryPortOffset
+    if (!Array.isArray(portOffsetArray)) {
+      gameQueryPortOffset ? portOffsetArray = [gameQueryPortOffset] : portOffsetArray = [0]
+    }
+
+    const cachedPort = this.portCache[`${userOptions.address}:${userOptions.port}`]
+
+    // Use any cached port if port caching is enabled and user is not explicitly enforcing their given port
+    if (cachedPort && optionsCollection.portCache && !userOptions.givenPortOnly) {
+      addAttemptWithPort(cachedPort)
+    }
+
+    if (userOptions.port) {
+      if (!userOptions.givenPortOnly) {
+        portOffsetArray.forEach((portOffset) => { addAttemptWithPort(userOptions.port + portOffset) })
+        if (userOptions.port === gameOptions.port && gameQueryPort) { addAttemptWithPort(gameQueryPort) }
+      }
+
+      attempts.push(optionsCollection)
+    } else if (gameQueryPort) {
+      addAttemptWithPort(gameQueryPort)
+    } else if (gameOptions.port) {
+      portOffsetArray.forEach((portOffset) => { addAttemptWithPort(gameOptions.port + portOffset) })
+    } 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.maxRetries || gameOptions.maxRetries || defaultOptions.maxRetries
+
+    const retries = Array.from({ length: numRetries }, (x, i) => i)
+
+    const attemptOrder = []
+    if (optionsCollection.noBreadthOrder) {
+      attempts.forEach(attempt => retries.forEach(retry => attemptOrder.push({ attempt, retry })))
+    } else {
+      retries.forEach(retry => attempts.forEach(attempt => attemptOrder.push({ attempt, retry })))
+    }
+
+    let attemptNum = 0
+    const errors = []
+    for (const { attempt, retry } of attemptOrder) {
+      attemptNum++
+
+      try {
+        const response = await this._attempt(attempt)
+        if (attempt.portCache) {
+          this.portCache[`${userOptions.address}:${userOptions.port}`] = attempt.port
+        }
+        return response
+      } 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()
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/lib/Results.js

@@ -0,0 +1,36 @@
+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 = {}
+  version = ''
+
+  maxplayers = 0
+  numplayers = 0
+  players = new Players()
+  bots = new Players()
+
+  queryPort = 0
+}

data/lib/game_dig/node/node_modules/gamedig/lib/game-resolver.js

@@ -0,0 +1,27 @@
+import { games } from './games.js'
+
+export const lookup = (options) => {
+  const type = options.type
+
+  if (!type) { throw Error('No game specified') }
+
+  if (type.startsWith('protocol-')) {
+    return {
+      protocol: type.substring(9)
+    }
+  }
+
+  let game = games[type]
+
+  if (options.checkOldIDs) {
+    Object.keys(games).forEach((id) => {
+      if (games[id]?.extra?.old_id === type) {
+        game = games[id]
+      }
+    })
+  }
+
+  if (!game) { throw Error('Invalid game: ' + type) }
+
+  return game.options
+}

data/lib/game_dig/node/node_modules/gamedig/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)
+  }
+}