gamedigz 0.1.0

package/protocols/doom3.js

@@ -0,0 +1,148 @@
+import Core from './core.js'
+
+export default class doom3 extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+  }
+
+  async run (state) {
+    const body = await this.udpSend('\xff\xffgetInfo\x00PiNGPoNg\x00', packet => {
+      const reader = this.reader(packet)
+      const header = reader.uint(2)
+      if (header !== 0xffff) return
+      const header2 = reader.string()
+      if (header2 !== 'infoResponse') return
+      const challengePart1 = reader.string(4)
+      if (challengePart1 !== 'PiNG') return
+      // some doom3 implementations only return the first 4 bytes of the challenge
+      const challengePart2 = reader.string(4)
+      if (challengePart2 !== 'PoNg') reader.skip(-4)
+      return reader.rest()
+    })
+
+    let reader = this.reader(body)
+    const protoVersion = reader.uint(4)
+    state.raw.protocolVersion = (protoVersion >> 16) + '.' + (protoVersion & 0xffff)
+
+    // some doom implementations send us a packet size here, some don't (etqw does this)
+    // we can tell if this is a packet size, because the third and fourth byte will be 0 (no packets are that massive)
+    reader.skip(2)
+    const packetContainsSize = (reader.uint(2) === 0)
+    reader.skip(-4)
+
+    if (packetContainsSize) {
+      const size = reader.uint(4)
+      this.logger.debug('Received packet size: ' + size)
+    }
+
+    while (!reader.done()) {
+      const key = reader.string()
+      let value = this.stripColors(reader.string())
+      if (key === 'si_map') {
+        value = value.replace('maps/', '')
+        value = value.replace('.entities', '')
+      }
+      if (!key) break
+      state.raw[key] = value
+      this.logger.debug(key + '=' + value)
+    }
+
+    const isEtqw = state.raw.gamename && state.raw.gamename.toLowerCase().includes('etqw')
+
+    const rest = reader.rest()
+    let playerResult = this.attemptPlayerParse(rest, isEtqw, false, false, false)
+    if (!playerResult) playerResult = this.attemptPlayerParse(rest, isEtqw, true, false, false)
+    if (!playerResult) playerResult = this.attemptPlayerParse(rest, isEtqw, true, true, true)
+    if (!playerResult) {
+      throw new Error('Unable to find a suitable parse strategy for player list')
+    }
+    let players;
+    [players, reader] = playerResult
+
+    state.numplayers = players.length
+    for (const player of players) {
+      if (!player.ping || player.typeflag) { state.bots.push(player) } else { state.players.push(player) }
+    }
+
+    state.raw.osmask = reader.uint(4)
+    if (isEtqw) {
+      state.raw.ranked = reader.uint(1)
+      state.raw.timeleft = reader.uint(4)
+      state.raw.gamestate = reader.uint(1)
+      state.raw.servertype = reader.uint(1)
+      // 0 = regular, 1 = tv
+      if (state.raw.servertype === 0) {
+        state.raw.interestedClients = reader.uint(1)
+      } else if (state.raw.servertype === 1) {
+        state.raw.connectedClients = reader.uint(4)
+        state.raw.maxClients = reader.uint(4)
+      }
+    }
+
+    if (state.raw.si_name) state.name = state.raw.si_name
+    if (state.raw.si_map) state.map = state.raw.si_map
+    if (state.raw.si_maxplayers) state.maxplayers = parseInt(state.raw.si_maxplayers)
+    if (state.raw.si_maxPlayers) state.maxplayers = parseInt(state.raw.si_maxPlayers)
+    if (state.raw.si_usepass === '1') state.password = true
+    if (state.raw.si_needPass === '1') state.password = true
+    if (this.options.port === 27733) state.gamePort = 3074 // etqw has a different query and game port
+  }
+
+  attemptPlayerParse (rest, isEtqw, hasClanTag, hasClanTagPos, hasTypeFlag) {
+    this.logger.debug('starting player parse attempt:')
+    this.logger.debug('isEtqw: ' + isEtqw)
+    this.logger.debug('hasClanTag: ' + hasClanTag)
+    this.logger.debug('hasClanTagPos: ' + hasClanTagPos)
+    this.logger.debug('hasTypeFlag: ' + hasTypeFlag)
+    const reader = this.reader(rest)
+    let lastId = -1
+    const players = []
+    while (true) {
+      this.logger.debug('---')
+      if (reader.done()) {
+        this.logger.debug('* aborting attempt, overran buffer *')
+        return null
+      }
+      const player = {}
+      player.id = reader.uint(1)
+      this.logger.debug('id: ' + player.id)
+      if (player.id <= lastId || player.id > 0x20) {
+        this.logger.debug('* aborting attempt, invalid player id *')
+        return null
+      }
+      lastId = player.id
+      if (player.id === 0x20) {
+        this.logger.debug('* player parse successful *')
+        break
+      }
+      player.ping = reader.uint(2)
+      this.logger.debug('ping: ' + player.ping)
+      if (!isEtqw) {
+        player.rate = reader.uint(4)
+        this.logger.debug('rate: ' + player.rate)
+      }
+      player.name = this.stripColors(reader.string())
+      this.logger.debug('name: ' + player.name)
+      if (hasClanTag) {
+        if (hasClanTagPos) {
+          const clanTagPos = reader.uint(1)
+          this.logger.debug('clanTagPos: ' + clanTagPos)
+        }
+        player.clantag = this.stripColors(reader.string())
+        this.logger.debug('clan tag: ' + player.clantag)
+      }
+      if (hasTypeFlag) {
+        player.typeflag = reader.uint(1)
+        this.logger.debug('type flag: ' + player.typeflag)
+      }
+      players.push(player)
+    }
+    return [players, reader]
+  }
+
+  stripColors (str) {
+    // uses quake 3 color codes
+    return str.replace(/\^(X.{6}|.)/g, '')
+  }
+}

package/protocols/eco.js

@@ -0,0 +1,20 @@
+import Core from './core.js'
+
+export default class eco extends Core {
+  async run (state) {
+    if (!this.options.port) this.options.port = 3001
+
+    const request = await this.request({
+      url: `http://${this.options.address}:${this.options.port}/frontpage`,
+      responseType: 'json'
+    })
+    const serverInfo = request.Info
+
+    state.name = serverInfo.Description
+    state.numplayers = serverInfo.OnlinePlayers;
+    state.maxplayers = serverInfo.TotalPlayers
+    state.password = serverInfo.HasPassword
+    state.gamePort = serverInfo.GamePort
+    state.raw = serverInfo
+  }
+}

package/protocols/eldewrito.js

@@ -0,0 +1,21 @@
+import Core from './core.js'
+
+export default class eldewrito extends Core {
+  async run (state) {
+    const json = await this.request({
+      url: 'http://' + this.options.address + ':' + this.options.port,
+      responseType: 'json'
+    })
+
+    for (const one of json.players) {
+      state.players.push({ name: one.name, team: one.team })
+    }
+
+    state.name = json.name
+    state.map = json.map
+    state.maxplayers = json.maxPlayers
+    state.connect = this.options.address + ':' + json.port
+
+    state.raw = json
+  }
+}

package/protocols/epic.js

@@ -0,0 +1,95 @@
+import Core from './core.js'
+
+export default class Epic extends Core {
+  constructor () {
+    super()
+
+    /**
+     * To get information about game servers using Epic's EOS, you need some credentials to authenticate using OAuth2.
+     *
+     * https://dev.epicgames.com/docs/web-api-ref/authentication
+     *
+     * These credentials can be provided by the game developers or extracted from the game's files.
+     */
+    this.clientId = null
+    this.clientSecret = null
+    this.deploymentId = null
+    this.epicApi = 'https://api.epicgames.dev'
+    this.accessToken = null
+
+    // Don't use the tcp ping probing
+    this.usedTcp = true
+  }
+
+  async run (state) {
+    await this.getAccessToken()
+    await this.queryInfo(state)
+    await this.cleanup(state)
+  }
+
+  async getAccessToken () {
+    this.logger.debug('Requesting acess token ...')
+
+    const url = `${this.epicApi}/auth/v1/oauth/token`
+    const body = `grant_type=client_credentials&deployment_id=${this.deploymentId}`
+    const headers = {
+      Authorization: `Basic ${Buffer.from(`${this.clientId}:${this.clientSecret}`).toString('base64')}`,
+      'Content-Type': 'application/x-www-form-urlencoded'
+    }
+
+    this.logger.debug(`POST: ${url}`)
+    const response = await this.request({ url, body, headers, method: 'POST', responseType: 'json' })
+
+    this.accessToken = response.access_token
+  }
+
+  async queryInfo (state) {
+    const url = `${this.epicApi}/matchmaking/v1/${this.deploymentId}/filter`
+    const body = {
+      criteria: [
+        {
+          key: 'attributes.ADDRESS_s',
+          op: 'EQUAL',
+          value: this.options.address
+        }
+      ]
+    }
+    const headers = {
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+      Authorization: `Bearer ${this.accessToken}`
+    }
+
+    this.logger.debug(`POST: ${url}`)
+    const response = await this.request({ url, json: body, headers, method: 'POST', responseType: 'json' })
+
+    // Epic returns a list of sessions, we need to find the one with the desired port.
+    const hasDesiredPort = (session) => session.attributes.ADDRESSBOUND_s === `0.0.0.0:${this.options.port}` ||
+      session.attributes.ADDRESSBOUND_s === `${this.options.address}:${this.options.port}`
+
+    const desiredServer = response.sessions.find(hasDesiredPort)
+
+    if (!desiredServer) {
+      throw new Error('Server not found')
+    }
+
+    state.name = desiredServer.attributes.CUSTOMSERVERNAME_s
+    state.map = desiredServer.attributes.MAPNAME_s
+    state.password = desiredServer.attributes.SERVERPASSWORD_b
+    state.numplayers = desiredServer.totalPlayers
+    state.maxplayers = desiredServer.settings.maxPublicPlayers
+
+    for (const player of desiredServer.publicPlayers) {
+      state.players.push({
+        name: player.name,
+        raw: player
+      })
+    }
+
+    state.raw = desiredServer
+  }
+
+  async cleanup (state) {
+    this.accessToken = null
+  }
+}

package/protocols/ffow.js

@@ -0,0 +1,38 @@
+import valve from './valve.js'
+
+export default class ffow extends valve {
+  constructor () {
+    super()
+    this.byteorder = 'be'
+    this.legacyChallenge = true
+  }
+
+  async queryInfo (state) {
+    this.logger.debug('Requesting ffow info ...')
+    const b = await this.sendPacket(
+      0x46,
+      'LSQ',
+      0x49
+    )
+
+    const reader = this.reader(b)
+    state.raw.protocol = reader.uint(1)
+    state.name = reader.string()
+    state.map = reader.string()
+    state.raw.mod = reader.string()
+    state.raw.gamemode = reader.string()
+    state.raw.description = reader.string()
+    state.raw.version = reader.string()
+    state.gamePort = reader.uint(2)
+    state.numplayers = reader.uint(1)
+    state.maxplayers = reader.uint(1)
+    state.raw.listentype = String.fromCharCode(reader.uint(1))
+    state.raw.environment = String.fromCharCode(reader.uint(1))
+    state.password = !!reader.uint(1)
+    state.raw.secure = reader.uint(1)
+    state.raw.averagefps = reader.uint(1)
+    state.raw.round = reader.uint(1)
+    state.raw.maxrounds = reader.uint(1)
+    state.raw.timeleft = reader.uint(2)
+  }
+}

package/protocols/fivem.js

@@ -0,0 +1,33 @@
+import quake2 from './quake2.js'
+
+export default class fivem extends quake2 {
+  constructor () {
+    super()
+    this.sendHeader = 'getinfo xxx'
+    this.responseHeader = 'infoResponse'
+    this.encoding = 'utf8'
+  }
+
+  async run (state) {
+    await super.run(state)
+
+    {
+      const json = await this.request({
+        url: 'http://' + this.options.address + ':' + this.options.port + '/info.json',
+        responseType: 'json'
+      })
+      state.raw.info = json
+    }
+
+    {
+      const json = await this.request({
+        url: 'http://' + this.options.address + ':' + this.options.port + '/players.json',
+        responseType: 'json'
+      })
+      state.raw.players = json
+      for (const player of json) {
+        state.players.push({ name: player.name, ping: player.ping })
+      }
+    }
+  }
+}

package/protocols/gamespy1.js

@@ -0,0 +1,181 @@
+import Core from './core.js'
+
+const stringKeys = new Set([
+  'website',
+  'gametype',
+  'gamemode',
+  'player'
+])
+
+function normalizeEntry ([key, value]) {
+  key = key.toLowerCase()
+  const split = key.split('_')
+  let keyType = key
+
+  if (split.length === 2 && !isNaN(Number(split[1]))) {
+    keyType = split[0]
+  }
+
+  if (!stringKeys.has(keyType) && !keyType.includes('name')) { // todo! the latter check might be problematic, fails on key "name_tag_distance_scope"
+    if (value.toLowerCase() === 'true') {
+      value = true
+    } else if (value.toLowerCase() === 'false') {
+      value = false
+    } else if (value.length && !isNaN(Number(value))) {
+      value = Number(value)
+    }
+  }
+
+  return [key, value]
+}
+
+export default class gamespy1 extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+    this.byteorder = 'be'
+  }
+
+  async run (state) {
+    const raw = await this.sendPacket('\\status\\xserverquery')
+    // Convert all keys to lowercase and normalize value types
+    const data = Object.fromEntries(Object.entries(raw).map(entry => normalizeEntry(entry)))
+    state.raw = data
+    if ('hostname' in data) state.name = data.hostname
+    if ('mapname' in data) state.map = data.mapname
+    if (this.trueTest(data.password)) state.password = true
+    if ('maxplayers' in data) state.maxplayers = Number(data.maxplayers)
+    if ('hostport' in data) state.gamePort = Number(data.hostport)
+
+    const teamOffByOne = data.gamename === 'bfield1942'
+    const playersById = {}
+    const teamNamesById = {}
+    for (const ident of Object.keys(data)) {
+      const split = ident.split('_')
+      if (split.length !== 2) continue
+      let key = split[0].toLowerCase()
+      const id = Number(split[1])
+      if (isNaN(id)) continue
+      let value = data[ident]
+
+      delete data[ident]
+
+      if (key !== 'team' && key.startsWith('team')) {
+        // Info about a team
+        if (key === 'teamname') {
+          teamNamesById[id] = value
+        } else {
+          // other team info which we don't track
+        }
+      } else {
+        // Info about a player
+        if (!(id in playersById)) playersById[id] = {}
+
+        if (key === 'playername' || key === 'player') {
+          key = 'name'
+        }
+        if (key === 'team' && !isNaN(value)) { // todo! technically, this NaN check isn't needed.
+          key = 'teamId'
+          value += teamOffByOne ? -1 : 0
+        }
+
+        playersById[id][key] = value
+      }
+    }
+    state.raw.teams = teamNamesById
+
+    const players = Object.values(playersById)
+
+    const seenHashes = new Set()
+    for (const player of players) {
+      // Some servers (bf1942) report the same player multiple times (bug?)
+      // Ignore these duplicates
+      if (player.keyhash) {
+        if (seenHashes.has(player.keyhash)) {
+          this.logger.debug('Rejected player with hash ' + player.keyhash + ' (Duplicate keyhash)')
+          continue
+        } else {
+          seenHashes.add(player.keyhash)
+        }
+      }
+
+      // Convert player's team ID to team name if possible
+      if (Object.prototype.hasOwnProperty.call(player, 'teamId')) {
+        if (Object.keys(teamNamesById).length) {
+          player.team = teamNamesById[player.teamId] || ''
+        } else {
+          player.team = player.teamId
+          delete player.teamId
+        }
+      }
+
+      state.players.push(player)
+    }
+
+    state.numplayers = state.players.length
+  }
+
+  async sendPacket (type) {
+    let receivedQueryId
+    const output = {}
+    const parts = new Set()
+    let maxPartNum = 0
+
+    return await this.udpSend(type, buffer => {
+      const reader = this.reader(buffer)
+      const str = reader.string(buffer.length)
+      const split = str.split('\\')
+      split.shift()
+      const data = {}
+      while (split.length) {
+        const key = split.shift()
+        const value = split.shift() || ''
+        data[key] = value
+      }
+
+      let queryId, partNum
+      const partFinal = ('final' in data)
+      if (data.queryid) {
+        const split = data.queryid.split('.')
+        if (split.length >= 2) {
+          partNum = Number(split[1])
+        }
+        queryId = split[0]
+      }
+      delete data.final
+      delete data.queryid
+      this.logger.debug('Received part num=' + partNum + ' queryId=' + queryId + ' final=' + partFinal)
+
+      if (queryId) {
+        if (receivedQueryId && receivedQueryId !== queryId) {
+          this.logger.debug('Rejected packet (Wrong query ID)')
+          return
+        } else if (!receivedQueryId) {
+          receivedQueryId = queryId
+        }
+      }
+      if (!partNum) {
+        partNum = parts.size
+        this.logger.debug('No part number received (assigned #' + partNum + ')')
+      }
+      if (parts.has(partNum)) {
+        this.logger.debug('Rejected packet (Duplicate part)')
+        return
+      }
+      parts.add(partNum)
+      if (partFinal) {
+        maxPartNum = partNum
+      }
+
+      this.logger.debug('Received part #' + partNum + ' of ' + (maxPartNum || '?'))
+      for (const i of Object.keys(data)) {
+        output[i] = data[i]
+      }
+      if (maxPartNum && parts.size === maxPartNum) {
+        this.logger.debug('Received all parts')
+        this.logger.debug(output)
+        return output
+      }
+    })
+  }
+}

package/protocols/gamespy2.js

@@ -0,0 +1,144 @@
+import Core from './core.js'
+
+export default class gamespy2 extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+    this.byteorder = 'be'
+  }
+
+  async run (state) {
+    // Parse info
+    {
+      const body = await this.sendPacket([0xff, 0, 0])
+      const reader = this.reader(body)
+      while (!reader.done()) {
+        const key = reader.string()
+        const value = reader.string()
+        if (!key) break
+        state.raw[key] = value
+      }
+      if ('hostname' in state.raw) state.name = state.raw.hostname
+      if ('mapname' in state.raw) state.map = state.raw.mapname
+      if (this.trueTest(state.raw.password)) state.password = true
+      if ('maxplayers' in state.raw) state.maxplayers = parseInt(state.raw.maxplayers)
+      if ('hostport' in state.raw) state.gamePort = parseInt(state.raw.hostport)
+    }
+
+    // Parse players
+    {
+      const body = await this.sendPacket([0, 0xff, 0])
+      const reader = this.reader(body)
+      for (const rawPlayer of this.readFieldData(reader)) {
+        state.players.push(rawPlayer)
+      }
+
+      if ('numplayers' in state.raw) state.numplayers = parseInt(state.raw.numplayers)
+      else state.numplayers = state.players.length
+    }
+
+    // Parse teams
+    {
+      const body = await this.sendPacket([0, 0, 0xff])
+      const reader = this.reader(body)
+      state.raw.teams = this.readFieldData(reader)
+    }
+
+    // Special case for america's army 1 and 2
+    // both use gamename = "armygame"
+    if (state.raw.gamename === 'armygame') {
+      const stripColor = (str) => {
+        // uses unreal 2 color codes
+        return str.replace(/\x1b...|[\x00-\x1a]/g, '')
+      }
+      state.name = stripColor(state.name)
+      state.map = stripColor(state.map)
+      for (const key of Object.keys(state.raw)) {
+        if (typeof state.raw[key] === 'string') {
+          state.raw[key] = stripColor(state.raw[key])
+        }
+      }
+      for (const player of state.players) {
+        if (!('name' in player)) continue
+        player.name = stripColor(player.name)
+      }
+    }
+  }
+
+  async sendPacket (type) {
+    const request = Buffer.concat([
+      Buffer.from([0xfe, 0xfd, 0x00]), // gamespy2
+      Buffer.from([0x00, 0x00, 0x00, 0x01]), // ping ID
+      Buffer.from(type)
+    ])
+    return await this.udpSend(request, buffer => {
+      const reader = this.reader(buffer)
+      const header = reader.uint(1)
+      if (header !== 0) return
+      const pingId = reader.uint(4)
+      if (pingId !== 1) return
+      return reader.rest()
+    })
+  }
+
+  readFieldData (reader) {
+    reader.uint(1) // always 0
+    const count = reader.uint(1) // number of rows in this data
+
+    // some games omit the count byte entirely if it's 0 or at random (like americas army)
+    // Luckily, count should always be <64, and ascii characters will typically be >64,
+    // so we can detect this.
+    if (count > 64) {
+      reader.skip(-1)
+      this.logger.debug('Detected missing count byte, rewinding by 1')
+    } else {
+      this.logger.debug('Detected row count: ' + count)
+    }
+
+    this.logger.debug(() => 'Reading fields, starting at: ' + reader.rest())
+
+    const fields = []
+    while (!reader.done()) {
+      const field = reader.string()
+      if (!field) break
+      fields.push(field)
+      this.logger.debug('field:' + field)
+    }
+
+    if (!fields.length) return []
+
+    const units = []
+    while (!reader.done()) {
+      const unit = {}
+      for (let iField = 0; iField < fields.length; iField++) {
+        let key = fields[iField]
+        let value = reader.string()
+        if (!value && iField === 0) return units
+
+        this.logger.debug('value:' + value)
+        if (key === 'player_') key = 'name'
+        else if (key === 'score_') key = 'score'
+        else if (key === 'deaths_') key = 'deaths'
+        else if (key === 'ping_') key = 'ping'
+        else if (key === 'team_') key = 'team'
+        else if (key === 'kills_') key = 'kills'
+        else if (key === 'team_t') key = 'name'
+        else if (key === 'tickets_t') key = 'tickets'
+
+        if (
+          key === 'score' || key === 'deaths' ||
+                    key === 'ping' || key === 'team' ||
+                    key === 'kills' || key === 'tickets'
+        ) {
+          if (value === '') continue
+          value = parseInt(value)
+        }
+
+        unit[key] = value
+      }
+      units.push(unit)
+    }
+
+    return units
+  }
+}