game_dig 0.0.1 → 0.2.0

data/lib/game_dig/node/node_modules/gamedig/protocols/core.js

@@ -0,0 +1,369 @@
+import { EventEmitter } from 'node:events'
+import * as net from 'node:net'
+import got from 'got'
+import Reader from '../lib/reader.js'
+import { debugDump } from '../lib/HexUtil.js'
+import Logger from '../lib/Logger.js'
+import DnsResolver from '../lib/DnsResolver.js'
+import { Results } from '../lib/Results.js'
+import Promises from '../lib/Promises.js'
+import { Telnet } from 'telnet-client'
+
+let uid = 0
+
+export default class Core extends EventEmitter {
+  constructor () {
+    super()
+    this.encoding = 'utf8'
+    this.byteorder = 'le'
+    this.delimiter = '\0'
+    this.srvRecord = null
+    this.abortedPromise = null
+    this.logger = new Logger()
+    this.dnsResolver = new DnsResolver(this.logger)
+
+    // Sent to us by QueryRunner
+    this.options = null
+    /** @type GlobalUdpSocket */
+    this.udpSocket = null
+    this.shortestRTT = 0
+    this.usedTcp = false
+
+    this.telnetClient = new Telnet()
+  }
+
+  // Runs a single attempt with a timeout and cleans up afterward
+  async runOnceSafe () {
+    const { debug, attemptTimeout } = this.options
+
+    if (debug) {
+      this.logger.debugEnabled = true
+    }
+    this.logger.prefix = 'Q#' + (uid++)
+
+    this.logger.debug('Starting')
+    this.logger.debug('Protocol: ' + this.constructor.name)
+    this.logger.debug('Options:', this.options)
+
+    let abortCall = null
+    this.abortedPromise = new Promise((_resolve, reject) => {
+      abortCall = () => reject(new Error('Query is finished -- cancelling outstanding promises'))
+    }).catch(() => {
+      // Make sure that if this promise isn't attached to, it doesn't throw an unhandled promise rejection
+    })
+
+    let timeout
+    try {
+      const promise = this.runOnce()
+      timeout = Promises.createTimeout(attemptTimeout, 'Attempt')
+      const result = await Promise.race([promise, timeout])
+      this.logger.debug('Query was successful')
+      return result
+    } catch (e) {
+      this.logger.debug('Query failed with error', e)
+      throw e
+    } finally {
+      timeout?.cancel()
+      try {
+        abortCall?.()
+      } catch (e) {
+        this.logger.debug('Error during abort cleanup: ' + e.stack)
+      }
+    }
+  }
+
+  async runOnce () {
+    const { options, dnsResolver } = this
+
+    if (('host' in options) && !('address' in options)) {
+      const resolved = await dnsResolver.resolve(options.host, options.ipFamily, this.srvRecord)
+      options.address = resolved.address
+      options.port ||= resolved.port
+    }
+
+    const state = new Results()
+    await this.run(state)
+
+    state.queryPort = options.port
+    // because lots of servers prefix with spaces to try to appear first
+    state.name = (state.name || '').trim()
+    state.connect = state.connect || `${state.gameHost || options.host || options.address}:${state.gamePort || options.port}`
+    state.ping = this.shortestRTT
+    state.version = String(state.version) // #734 - we should eventually do this for the entire query schema
+
+    delete state.gameHost
+    delete state.gamePort
+
+    this.logger.debug(log => {
+      log('Size of players array:', state.players.length)
+      log('Size of bots array:', state.bots.length)
+    })
+
+    return state
+  }
+
+  async run (/** Results */ state) {}
+
+  /** Param can be a time in ms, or a promise (which will be timed) */
+  registerRtt (param) {
+    if (param instanceof Promise) {
+      const start = Date.now()
+      param.then(() => {
+        this.registerRtt(Date.now() - start)
+      }).catch((_) => {})
+    } else {
+      this.logger.debug('Registered RTT: ' + param + 'ms')
+      if (this.shortestRTT === 0 || param < this.shortestRTT) {
+        this.shortestRTT = param
+      }
+    }
+  }
+
+  // utils
+  /** @returns {Reader} */
+  reader (buffer) {
+    return new Reader(this, buffer)
+  }
+
+  translate (obj, trans) {
+    for (const from of Object.keys(trans)) {
+      const to = trans[from]
+      if (from in obj) {
+        if (to) obj[to] = obj[from]
+        delete obj[from]
+      }
+    }
+  }
+
+  trueTest (str) {
+    if (typeof str === 'boolean') return str
+    if (typeof str === 'number') return str !== 0
+    if (typeof str === 'string') {
+      if (str.toLowerCase() === 'true') return true
+      if (str.toLowerCase() === 'yes') return true
+      if (str === '1') return true
+    }
+    return false
+  }
+
+  assertValidPort (port) {
+    if (!port) {
+      throw new Error('Could not determine port to query. Did you provide a port?')
+    }
+    if (port < 1 || port > 65535) {
+      throw new Error('Invalid tcp/ip port: ' + port)
+    }
+  }
+
+  /**
+     * @template T
+     * @param {function(NodeJS.Socket):Promise<T>} fn
+     * @param {number=} port
+     * @returns {Promise<T>}
+     */
+  async withTcp (fn, port) {
+    this.usedTcp = true
+    const { options, logger } = this
+    const address = this.options.address
+    port ??= options.port
+
+    this.assertValidPort(port)
+
+    let socket, connectionTimeout
+    try {
+      socket = net.connect(port, address)
+      socket.setNoDelay(true)
+
+      // Prevent unhandled 'error' events from dumping straight to console
+      socket.on('error', () => {})
+
+      logger.debug(log => {
+        logger.debug(address + ':' + port + ' TCP Connecting')
+        const writeHook = socket.write
+        socket.write = (...args) => {
+          log(address + ':' + port + ' TCP-->')
+          log(debugDump(args[0]))
+          writeHook.apply(socket, args)
+        }
+
+        socket.on('error', e => log('TCP Error:', e))
+        socket.on('close', () => log('TCP Closed'))
+        socket.on('data', (data) => {
+          log(`${address}:${port} <--TCP`)
+          log(data)
+        })
+        socket.on('ready', () => log(`${address}:${port} TCP Connected`))
+      })
+
+      const connectionPromise = new Promise((resolve, reject) => {
+        socket.on('ready', resolve)
+        socket.on('close', () => reject(new Error('TCP Connection Refused')))
+      })
+      this.registerRtt(connectionPromise)
+      connectionTimeout = Promises.createTimeout(this.options.socketTimeout, 'TCP Opening')
+      await Promise.race([
+        connectionPromise,
+        connectionTimeout,
+        this.abortedPromise
+      ])
+      return await fn(socket)
+    } finally {
+      socket?.destroy()
+      connectionTimeout?.cancel()
+    }
+  }
+
+  /**
+     * @template T
+     * @param {NodeJS.Socket} socket
+     * @param {Buffer|string} buffer
+     * @param {function(Buffer):T} ondata
+     * @returns Promise<T>
+     */
+  async tcpSend (socket, buffer, ondata) {
+    let timeout
+    try {
+      const promise = new Promise((resolve, reject) => {
+        let received = Buffer.from([])
+        const onData = (data) => {
+          received = Buffer.concat([received, data])
+          let result
+          try {
+            result = ondata(received)
+          } catch (e) {
+            reject(e)
+          }
+          if (result !== undefined) {
+            socket.removeListener('data', onData)
+            resolve(result)
+          }
+        }
+        socket.on('data', onData)
+        socket.write(buffer)
+      })
+      timeout = Promises.createTimeout(this.options.socketTimeout, 'TCP')
+      return await Promise.race([promise, timeout, this.abortedPromise])
+    } finally {
+      timeout?.cancel()
+    }
+  }
+
+  /**
+     * @param {Buffer|string} buffer
+     * @param {function(Buffer):T=} onPacket
+     * @param {(function():T)=} onTimeout
+     * @returns Promise<T>
+     * @template T
+     */
+  async udpSend (buffer, onPacket, onTimeout) {
+    const { address, port, debug, socketTimeout } = this.options
+    this.assertValidPort(port)
+
+    if (typeof buffer === 'string') buffer = Buffer.from(buffer, 'binary')
+
+    const socket = this.udpSocket
+    await socket.send(buffer, address, port, this.options.debug)
+
+    if (!onPacket && !onTimeout) {
+      return null
+    }
+
+    let socketCallback
+    let timeout
+
+    try {
+      const promise = new Promise((resolve, reject) => {
+        const start = Date.now()
+        socketCallback = (fromAddress, fromPort, buffer) => {
+          try {
+            if (fromAddress !== address || fromPort !== port) return
+            this.registerRtt(Date.now() - start)
+            const result = onPacket(buffer)
+            if (result !== undefined) {
+              this.logger.debug('UDP send finished by callback')
+              resolve(result)
+            }
+          } catch (e) {
+            reject(e)
+          }
+        }
+        socket.addCallback(socketCallback, debug)
+      })
+      timeout = Promises.createTimeout(socketTimeout, 'UDP')
+      const wrappedTimeout = Promise.resolve(timeout).catch((e) => {
+        this.logger.debug('UDP timeout detected')
+        if (onTimeout) {
+          const result = onTimeout()
+          if (result !== undefined) {
+            this.logger.debug('UDP timeout resolved by callback')
+            return result
+          }
+        }
+        throw e
+      })
+
+      return await Promise.race([promise, wrappedTimeout, this.abortedPromise])
+    } finally {
+      timeout?.cancel()
+      socketCallback && socket.removeCallback(socketCallback)
+    }
+  }
+
+  async tcpPing () {
+    // This will give a much more accurate RTT than using the rtt of an http request.
+    if (!this.usedTcp) {
+      await this.withTcp(() => {})
+    }
+  }
+
+  async request (params) {
+    await this.tcpPing()
+
+    let requestPromise
+    try {
+      requestPromise = got({
+        ...params,
+        timeout: {
+          request: this.options.socketTimeout
+        },
+        retry: {
+          limit: 0
+        }
+      })
+      this.logger.debug(log => {
+        log(() => params.url + ' HTTP-->')
+        requestPromise
+          .then((response) => log(params.url + ' <--HTTP ' + response.statusCode))
+          .catch(() => {})
+      })
+      const wrappedPromise = requestPromise.then(response => {
+        if (response.statusCode !== 200) throw new Error('Bad status code: ' + response.statusCode)
+        return response.body
+      })
+      return await Promise.race([wrappedPromise, this.abortedPromise])
+    } finally {
+      requestPromise?.cancel()
+    }
+  }
+
+  async telnetConnect (params) {
+    const { socketTimeout, host } = this.options
+
+    await this.telnetClient.connect({
+      timeout: socketTimeout,
+      execTimeout: socketTimeout,
+      host,
+      debug: this.debugEnabled,
+      ...params
+    })
+  }
+
+  async telnetExecute (command) {
+    return await this.telnetClient.exec(command)
+  }
+
+  async telnetClose () {
+    await this.telnetClient.end()
+    await this.telnetClient.destroy()
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/protocols/cs2d.js

@@ -0,0 +1,65 @@
+import Core from './core.js'
+
+export default class cs2d extends Core {
+  async run (state) {
+    const reader = await this.sendQuery(
+      Buffer.from('\x01\x00\xFB\x01\xF5\x03\xFB\x05', 'binary'),
+      Buffer.from('\x01\x00\xFB\x01', 'binary')
+    )
+    const flags = reader.uint(1)
+    state.raw.flags = flags
+    state.password = this.readFlag(flags, 0)
+    state.raw.registeredOnly = this.readFlag(flags, 1)
+    state.raw.fogOfWar = this.readFlag(flags, 2)
+    state.raw.friendlyFire = this.readFlag(flags, 3)
+    state.raw.botsEnabled = this.readFlag(flags, 5)
+    state.raw.luaScripts = this.readFlag(flags, 6)
+    state.raw.forceLight = this.readFlag(flags, 7)
+    state.name = this.readString(reader)
+    state.map = this.readString(reader)
+    state.numplayers = reader.uint(1)
+    state.maxplayers = reader.uint(1)
+    if (flags & 32) {
+      state.raw.gamemode = reader.uint(1)
+    } else {
+      state.raw.gamemode = 0
+    }
+    state.raw.numbots = reader.uint(1)
+    const flags2 = reader.uint(1)
+    state.raw.flags2 = flags2
+    state.raw.recoil = this.readFlag(flags2, 0)
+    state.raw.offScreenDamage = this.readFlag(flags2, 1)
+    state.raw.hasDownloads = this.readFlag(flags2, 2)
+    reader.skip(2)
+    const players = reader.uint(1)
+    for (let i = 0; i < players; i++) {
+      const player = {}
+      player.id = reader.uint(1)
+      player.name = this.readString(reader)
+      player.team = reader.uint(1)
+      player.score = reader.uint(4)
+      player.deaths = reader.uint(4)
+      state.players.push(player)
+    }
+  }
+
+  async sendQuery (request, expectedHeader) {
+    // Send multiple copies of the request packet, because cs2d likes to just ignore them randomly
+    await this.udpSend(request)
+    await this.udpSend(request)
+    return await this.udpSend(request, (buffer) => {
+      const reader = this.reader(buffer)
+      const header = reader.part(4)
+      if (!header.equals(expectedHeader)) return
+      return reader
+    })
+  }
+
+  readFlag (flags, offset) {
+    return !!(flags & (1 << offset))
+  }
+
+  readString (reader) {
+    return reader.pascalString(1)
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/protocols/dayz.js

@@ -0,0 +1,196 @@
+import valve from './valve.js'
+import { Buffer } from 'node:buffer'
+
+export default class dayz extends valve {
+  async run (state) {
+    if (!this.options.port) this.options.port = 27016
+    await super.queryInfo(state)
+    await super.queryChallenge()
+    await super.queryPlayers(state)
+    await this.queryRules(state)
+
+    this.processQueryInfo(state)
+    await super.cleanup(state)
+  }
+
+  async queryRules (state) {
+    if (!this.options.requestRules) {
+      return
+    }
+
+    const rules = {}
+    state.raw.rules = rules
+    const dayZPayload = []
+
+    this.logger.debug('Requesting rules ...')
+
+    const b = await this.sendPacket(0x56, null, 0x45, true)
+    if (b === null && !this.options.requestRulesRequired) return // timed out - the server probably has rules disabled
+
+    let dayZPayloadEnded = false
+
+    const reader = this.reader(b)
+    const num = reader.uint(2)
+    for (let i = 0; i < num; i++) {
+      if (!dayZPayloadEnded) {
+        const one = reader.uint(1)
+        const two = reader.uint(1)
+        const three = reader.uint(1)
+        if (one !== 0 && two !== 0 && three === 0) {
+          while (true) {
+            const byte = reader.uint(1)
+            if (byte === 0) break
+            dayZPayload.push(byte)
+          }
+          continue
+        } else {
+          reader.skip(-3)
+          dayZPayloadEnded = true
+        }
+      }
+
+      const key = reader.string()
+      rules[key] = reader.string()
+    }
+
+    state.raw.dayzMods = this.readDayzMods(Buffer.from(dayZPayload))
+  }
+
+  processQueryInfo (state) {
+    // DayZ embeds some of the server information inside the tags attribute
+    if (!state.raw.tags) { return }
+
+    state.raw.dlcEnabled = false
+    state.raw.firstPerson = false
+    state.raw.privateHive = false
+    state.raw.external = false
+    state.raw.official = false
+
+    for (const tag of state.raw.tags) {
+      if (tag.startsWith('lqs')) {
+        const value = parseInt(tag.replace('lqs', ''))
+        if (!isNaN(value)) {
+          state.raw.queue = value
+        }
+      }
+      if (tag.includes('no3rd')) {
+        state.raw.firstPerson = true
+      }
+      if (tag.includes('isDLC')) {
+        state.raw.dlcEnabled = true
+      }
+      if (tag.includes('privHive')) {
+        state.raw.privateHive = true
+      }
+      if (tag.includes('external')) {
+        state.raw.external = true
+      }
+      if (tag.includes(':')) {
+        state.raw.time = tag
+      }
+      if (tag.startsWith('etm')) {
+        const value = parseInt(tag.replace('etm', ''))
+        if (!isNaN(value)) {
+          state.raw.dayAcceleration = value
+        }
+      }
+      if (tag.startsWith('entm')) {
+        const value = parseInt(tag.replace('entm', ''))
+        if (!isNaN(value)) {
+          state.raw.nightAcceleration = value
+        }
+      }
+    }
+
+    if (!state.raw.external && !state.raw.privateHive) {
+      state.raw.official = true
+    }
+  }
+
+  readDayzMods (/** Buffer */ buffer) {
+    if (!buffer.length) {
+      return {}
+    }
+
+    this.logger.debug('DAYZ BUFFER')
+    this.logger.debug(buffer)
+
+    const reader = this.reader(buffer)
+    const version = this.readDayzByte(reader)
+    const overflow = this.readDayzByte(reader)
+    const dlc1 = this.readDayzByte(reader)
+    const dlc2 = this.readDayzByte(reader)
+    this.logger.debug('version ' + version)
+    this.logger.debug('overflow ' + overflow)
+    this.logger.debug('dlc1 ' + dlc1)
+    this.logger.debug('dlc2 ' + dlc2)
+    if (dlc1) {
+      const unknown = this.readDayzUint(reader, 4) // ?
+      this.logger.debug('unknown ' + unknown)
+    }
+    if (dlc2) {
+      const unknown = this.readDayzUint(reader, 4) // ?
+      this.logger.debug('unknown ' + unknown)
+    }
+    const mods = []
+    mods.push(...this.readDayzModsSection(reader, true))
+    mods.push(...this.readDayzModsSection(reader, false))
+    this.logger.debug('dayz buffer rest:', reader.rest())
+    return mods
+  }
+
+  readDayzModsSection (/** Reader */ reader, withHeader) {
+    const out = []
+    const count = this.readDayzByte(reader)
+    this.logger.debug('dayz mod section withHeader:' + withHeader + ' count:' + count)
+    for (let i = 0; i < count; i++) {
+      if (reader.done()) break
+      const mod = {}
+      if (withHeader) {
+        mod.unknown = this.readDayzUint(reader, 4) // ?
+
+        // For some reason this is 4 on all of them, but doesn't exist on the last one? but only sometimes?
+        const offset = reader.offset()
+        const flag = this.readDayzByte(reader)
+        if (flag !== 4) reader.setOffset(offset)
+
+        mod.workshopId = this.readDayzUint(reader, 4)
+      }
+      mod.title = this.readDayzString(reader)
+      this.logger.debug(mod)
+      out.push(mod)
+    }
+    return out
+  }
+
+  readDayzUint (reader, bytes) {
+    const out = []
+    for (let i = 0; i < bytes; i++) {
+      out.push(this.readDayzByte(reader))
+    }
+    const buf = Buffer.from(out)
+    const r2 = this.reader(buf)
+    return r2.uint(bytes)
+  }
+
+  readDayzByte (reader) {
+    const byte = reader.uint(1)
+    if (byte === 1) {
+      const byte2 = reader.uint(1)
+      if (byte2 === 1) return 1
+      if (byte2 === 2) return 0
+      if (byte2 === 3) return 0xff
+      return 0 // ?
+    }
+    return byte
+  }
+
+  readDayzString (reader) {
+    const length = this.readDayzByte(reader)
+    const out = []
+    for (let i = 0; i < length; i++) {
+      out.push(this.readDayzByte(reader))
+    }
+    return Buffer.from(out).toString('utf8')
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/protocols/discord.js

@@ -0,0 +1,29 @@
+import Core from './core.js'
+
+export default class discord extends Core {
+  async run (state) {
+    const guildId = this.options.guildId
+    if (typeof guildId !== 'string') {
+      throw new Error('guildId option must be set when querying discord. Ensure the guildId is a string and not a number.' +
+                    " (It's too large of a number for javascript to store without losing precision)")
+    }
+    this.usedTcp = true
+    const raw = await this.request({
+      url: 'https://discordapp.com/api/guilds/' + guildId + '/widget.json'
+    })
+    const json = JSON.parse(raw)
+    state.name = json.name
+    if (json.instant_invite) {
+      state.connect = json.instant_invite
+    } else {
+      state.connect = 'https://discordapp.com/channels/' + guildId
+    }
+    for (const member of json.members) {
+      const { username: name, ...rest } = member
+      state.players.push({ name, ...rest })
+    }
+    delete json.members
+    state.maxplayers = 500000
+    state.raw = json
+  }
+}