gamedigz 0.1.0

package/protocols/gamespy3.js

@@ -0,0 +1,197 @@
+import Core from './core.js'
+
+export default class gamespy3 extends Core {
+  constructor () {
+    super()
+    this.sessionId = 1
+    this.encoding = 'latin1'
+    this.byteorder = 'be'
+    this.useOnlySingleSplit = false
+    this.isJc2mp = false
+  }
+
+  async run (state) {
+    const buffer = await this.sendPacket(9, false, false, false)
+    const reader = this.reader(buffer)
+    let challenge = parseInt(reader.string())
+    this.logger.debug('Received challenge key: ' + challenge)
+    if (challenge === 0) {
+      // Some servers send us a 0 if they don't want a challenge key used
+      // BF2 does this.
+      challenge = null
+    }
+
+    let requestPayload
+    if (this.isJc2mp) {
+      // they completely alter the protocol. because why not.
+      requestPayload = Buffer.from([0xff, 0xff, 0xff, 0x02])
+    } else {
+      requestPayload = Buffer.from([0xff, 0xff, 0xff, 0x01])
+    }
+    /** @type Buffer[] */
+    const packets = await this.sendPacket(0, challenge, requestPayload, true)
+
+    // iterate over the received packets
+    // the first packet will start off with k/v pairs, followed with data fields
+    // the following packets will only have data fields
+    state.raw.playerTeamInfo = {}
+
+    for (let iPacket = 0; iPacket < packets.length; iPacket++) {
+      const packet = packets[iPacket]
+      const reader = this.reader(packet)
+
+      this.logger.debug('Parsing packet #' + iPacket)
+      this.logger.debug(packet)
+
+      // Parse raw server key/values
+
+      if (iPacket === 0) {
+        while (!reader.done()) {
+          const key = reader.string()
+          if (!key) break
+
+          let value = reader.string()
+          while (value.match(/^p[0-9]+$/)) {
+            // fix a weird ut3 bug where some keys don't have values
+            value = reader.string()
+          }
+
+          state.raw[key] = value
+          this.logger.debug(key + ' = ' + value)
+        }
+      }
+
+      // Parse player, team, item array state
+
+      if (this.isJc2mp) {
+        state.raw.numPlayers2 = reader.uint(2)
+        while (!reader.done()) {
+          const player = {}
+          player.name = reader.string()
+          player.steamid = reader.string()
+          player.ping = reader.uint(2)
+          state.players.push(player)
+        }
+      } else {
+        while (!reader.done()) {
+          if (reader.uint(1) <= 2) continue
+          reader.skip(-1)
+          const fieldId = reader.string()
+          if (!fieldId) continue
+          const fieldIdSplit = fieldId.split('_')
+          const fieldName = fieldIdSplit[0]
+          const itemType = fieldIdSplit.length > 1 ? fieldIdSplit[1] : 'no_'
+
+          if (!(itemType in state.raw.playerTeamInfo)) {
+            state.raw.playerTeamInfo[itemType] = []
+          }
+          const items = state.raw.playerTeamInfo[itemType]
+
+          let offset = reader.uint(1)
+
+          this.logger.debug(() => 'Parsing new field: itemType=' + itemType + ' fieldName=' + fieldName + ' startOffset=' + offset)
+
+          while (!reader.done()) {
+            const item = reader.string()
+            if (!item) break
+
+            while (items.length <= offset) { items.push({}) }
+            items[offset][fieldName] = item
+            this.logger.debug('* ' + item)
+            offset++
+          }
+        }
+      }
+    }
+
+    // Turn all that raw state into something useful
+
+    if ('hostname' in state.raw) state.name = state.raw.hostname
+    else if ('servername' in state.raw) state.name = state.raw.servername
+    if ('mapname' in state.raw) state.map = state.raw.mapname
+    if (state.raw.password === '1') 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)
+
+    if ('' in state.raw.playerTeamInfo) {
+      for (const playerInfo of state.raw.playerTeamInfo['']) {
+        const player = {}
+        for (const from of Object.keys(playerInfo)) {
+          let key = from
+          let value = playerInfo[from]
+
+          if (key === 'player') key = 'name'
+          if (key === 'score' || key === 'ping' || key === 'team' || key === 'deaths' || key === 'pid') value = parseInt(value)
+          player[key] = value
+        }
+        state.players.push(player)
+      }
+    }
+
+    if ('numplayers' in state.raw) state.numplayers = parseInt(state.raw.numplayers)
+    else state.numplayers = state.players.length
+  }
+
+  async sendPacket (type, challenge, payload, assemble) {
+    const challengeLength = challenge === null ? 0 : 4
+    const payloadLength = payload ? payload.length : 0
+
+    const b = Buffer.alloc(7 + challengeLength + payloadLength)
+    b.writeUInt8(0xFE, 0)
+    b.writeUInt8(0xFD, 1)
+    b.writeUInt8(type, 2)
+    b.writeUInt32BE(this.sessionId, 3)
+    if (challengeLength) b.writeInt32BE(challenge, 7)
+    if (payloadLength) payload.copy(b, 7 + challengeLength)
+
+    let numPackets = 0
+    const packets = {}
+    return await this.udpSend(b, (buffer) => {
+      const reader = this.reader(buffer)
+      const iType = reader.uint(1)
+      if (iType !== type) {
+        this.logger.debug('Skipping packet, type mismatch')
+        return
+      }
+      const iSessionId = reader.uint(4)
+      if (iSessionId !== this.sessionId) {
+        this.logger.debug('Skipping packet, session id mismatch')
+        return
+      }
+
+      if (!assemble) {
+        return reader.rest()
+      }
+      if (this.useOnlySingleSplit) {
+        // has split headers, but they are worthless and only one packet is used
+        reader.skip(11)
+        return [reader.rest()]
+      }
+
+      reader.skip(9) // filler data -- usually set to 'splitnum\0'
+      let id = reader.uint(1)
+      const last = (id & 0x80)
+      id = id & 0x7f
+      if (last) numPackets = id + 1
+
+      reader.skip(1) // "another 'packet number' byte, but isn't understood."
+
+      packets[id] = reader.rest()
+      if (this.debug) {
+        this.logger.debug('Received packet #' + id + (last ? ' (last)' : ''))
+      }
+
+      if (!numPackets || Object.keys(packets).length !== numPackets) return
+
+      // assemble the parts
+      const list = []
+      for (let i = 0; i < numPackets; i++) {
+        if (!(i in packets)) {
+          throw new Error('Missing packet #' + i)
+        }
+        list.push(packets[i])
+      }
+      return list
+    })
+  }
+}

package/protocols/geneshift.js

@@ -0,0 +1,46 @@
+import Core from './core.js'
+
+export default class geneshift extends Core {
+  async run (state) {
+    await this.tcpPing()
+
+    const body = await this.request({
+      url: 'http://geneshift.net/game/receiveLobby.php'
+    })
+
+    const split = body.split('<br/>')
+    let found = null
+    for (const line of split) {
+      const fields = line.split('::')
+      const ip = fields[2]
+      const port = fields[3]
+      if (ip === this.options.address && parseInt(port) === this.options.port) {
+        found = fields
+        break
+      }
+    }
+
+    if (found === null) {
+      throw new Error('Server not found in list')
+    }
+
+    state.raw.countrycode = found[0]
+    state.raw.country = found[1]
+    state.name = found[4]
+    state.map = found[5]
+    state.numplayers = parseInt(found[6])
+    state.maxplayers = parseInt(found[7])
+    // fields[8] is unknown?
+    state.raw.rules = found[9]
+    state.raw.gamemode = parseInt(found[10])
+    state.raw.gangsters = parseInt(found[11])
+    state.raw.cashrate = parseInt(found[12])
+    state.raw.missions = !!parseInt(found[13])
+    state.raw.vehicles = !!parseInt(found[14])
+    state.raw.customweapons = !!parseInt(found[15])
+    state.raw.friendlyfire = !!parseInt(found[16])
+    state.raw.mercs = !!parseInt(found[17])
+    // fields[18] is unknown? listen server?
+    state.raw.version = found[19]
+  }
+}

package/protocols/goldsrc.js

@@ -0,0 +1,8 @@
+import valve from './valve.js'
+
+export default class goldsrc extends valve {
+  constructor () {
+    super()
+    this.goldsrcInfo = true
+  }
+}

package/protocols/hexen2.js

@@ -0,0 +1,14 @@
+import quake1 from './quake1.js'
+
+export default class hexen2 extends quake1 {
+  constructor () {
+    super()
+    this.sendHeader = '\xFFstatus\x0a'
+    this.responseHeader = '\xffn'
+  }
+
+  async run (state) {
+    await super.run(state)
+    state.gamePort = this.options.port - 50
+  }
+}

package/protocols/index.js

@@ -0,0 +1,61 @@
+import armagetron from './armagetron.js'
+import ase from './ase.js'
+import asa from './asa.js'
+import assettocorsa from './assettocorsa.js'
+import battlefield from './battlefield.js'
+import buildandshoot from './buildandshoot.js'
+import cs2d from './cs2d.js'
+import discord from './discord.js'
+import doom3 from './doom3.js'
+import eco from './eco.js'
+import eldewrito from './eldewrito.js'
+import epic from './epic.js'
+import ffow from './ffow.js'
+import fivem from './fivem.js'
+import gamespy1 from './gamespy1.js'
+import gamespy2 from './gamespy2.js'
+import gamespy3 from './gamespy3.js'
+import geneshift from './geneshift.js'
+import goldsrc from './goldsrc.js'
+import hexen2 from './hexen2.js'
+import jc2mp from './jc2mp.js'
+import kspdmp from './kspdmp.js'
+import mafia2mp from './mafia2mp.js'
+import mafia2online from './mafia2online.js'
+import minecraft from './minecraft.js'
+import minecraftbedrock from './minecraftbedrock.js'
+import minecraftvanilla from './minecraftvanilla.js'
+import mumble from './mumble.js'
+import mumbleping from './mumbleping.js'
+import nadeo from './nadeo.js'
+import openttd from './openttd.js'
+import quake1 from './quake1.js'
+import quake2 from './quake2.js'
+import quake3 from './quake3.js'
+import rfactor from './rfactor.js'
+import samp from './samp.js'
+import savage2 from './savage2.js'
+import starmade from './starmade.js'
+import starsiege from './starsiege.js'
+import teamspeak2 from './teamspeak2.js'
+import teamspeak3 from './teamspeak3.js'
+import terraria from './terraria.js'
+import tribes1 from './tribes1.js'
+import tribes1master from './tribes1master.js'
+import unreal2 from './unreal2.js'
+import ut3 from './ut3.js'
+import valve from './valve.js'
+import vcmp from './vcmp.js'
+import ventrilo from './ventrilo.js'
+import warsow from './warsow.js'
+import beammpmaster from './beammpmaster.js'
+import beammp from './beammp.js'
+import dayz from './dayz.js'
+
+export {
+  armagetron, ase, asa, assettocorsa, battlefield, buildandshoot, cs2d, discord, doom3, eco, epic, ffow, fivem, gamespy1,
+  gamespy2, gamespy3, geneshift, goldsrc, hexen2, jc2mp, kspdmp, mafia2mp, mafia2online, minecraft,
+  minecraftbedrock, minecraftvanilla, mumble, mumbleping, nadeo, openttd, quake1, quake2, quake3, rfactor, samp,
+  savage2, starmade, starsiege, teamspeak2, teamspeak3, terraria, tribes1, tribes1master, unreal2, ut3, valve,
+  vcmp, ventrilo, warsow, eldewrito, beammpmaster, beammp, dayz
+}

package/protocols/jc2mp.js

@@ -0,0 +1,16 @@
+import gamespy3 from './gamespy3.js'
+
+// supposedly, gamespy3 is the "official" query protocol for jcmp,
+// but it's broken (requires useOnlySingleSplit), and may not include some player names
+export default class jc2mp extends gamespy3 {
+  constructor () {
+    super()
+    this.useOnlySingleSplit = true
+    this.isJc2mp = true
+    this.encoding = 'utf8'
+  }
+
+  async run (state) {
+    await super.run(state)
+  }
+}

package/protocols/kspdmp.js

@@ -0,0 +1,28 @@
+import Core from './core.js'
+
+export default class kspdmp 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.nickname, team: one.team })
+    }
+
+    for (const key of Object.keys(json)) {
+      state.raw[key] = json[key]
+    }
+    state.name = json.server_name
+    state.maxplayers = json.max_players
+    state.gamePort = json.port
+    if (json.players) {
+      const split = json.players.split(', ')
+      for (const name of split) {
+        state.players.push({ name })
+      }
+    }
+    state.numplayers = state.players.length
+  }
+}

package/protocols/mafia2mp.js

@@ -0,0 +1,41 @@
+import Core from './core.js'
+
+export default class mafia2mp extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+    this.header = 'M2MP'
+    this.isMafia2Online = false
+  }
+
+  async run (state) {
+    const body = await this.udpSend(this.header, (buffer) => {
+      const reader = this.reader(buffer)
+      const header = reader.string(this.header.length)
+      if (header !== this.header) return
+      return reader.rest()
+    })
+
+    const reader = this.reader(body)
+    state.name = this.readString(reader)
+    state.numplayers = parseInt(this.readString(reader))
+    state.maxplayers = parseInt(this.readString(reader))
+    state.raw.gamemode = this.readString(reader)
+    state.password = !!reader.uint(1)
+    state.gamePort = this.options.port - 1
+
+    while (!reader.done()) {
+      const player = {}
+      player.name = this.readString(reader)
+      if (!player.name) break
+      if (this.isMafia2Online) {
+        player.ping = parseInt(this.readString(reader))
+      }
+      state.players.push(player)
+    }
+  }
+
+  readString (reader) {
+    return reader.pascalString(1, -1)
+  }
+}

package/protocols/mafia2online.js

@@ -0,0 +1,9 @@
+import mafia2mp from './mafia2mp.js'
+
+export default class mafia2online extends mafia2mp {
+  constructor () {
+    super()
+    this.header = 'M2Online'
+    this.isMafia2Online = true
+  }
+}

package/protocols/minecraft.js

@@ -0,0 +1,102 @@
+import Core from './core.js'
+import minecraftbedrock from './minecraftbedrock.js'
+import minecraftvanilla from './minecraftvanilla.js'
+import Gamespy3 from './gamespy3.js'
+
+/*
+Vanilla servers respond to minecraftvanilla only
+Some modded vanilla servers respond to minecraftvanilla and gamespy3, or gamespy3 only
+Some bedrock servers respond to gamespy3 only
+Some bedrock servers respond to minecraftbedrock only
+Unsure if any bedrock servers respond to gamespy3 and minecraftbedrock
+ */
+
+export default class minecraft extends Core {
+  constructor () {
+    super()
+    this.srvRecord = '_minecraft._tcp'
+  }
+
+  async run (state) {
+    /** @type {Promise<Results>[]} */
+    const promises = []
+
+    const vanillaResolver = new minecraftvanilla()
+    vanillaResolver.options = this.options
+    vanillaResolver.udpSocket = this.udpSocket
+    promises.push((async () => {
+      try { return await vanillaResolver.runOnceSafe() } catch (e) {}
+    })())
+
+    const gamespyResolver = new Gamespy3()
+    gamespyResolver.options = {
+      ...this.options,
+      encoding: 'utf8'
+    }
+    gamespyResolver.udpSocket = this.udpSocket
+    promises.push((async () => {
+      try { return await gamespyResolver.runOnceSafe() } catch (e) {}
+    })())
+
+    const bedrockResolver = new minecraftbedrock()
+    bedrockResolver.options = this.options
+    bedrockResolver.udpSocket = this.udpSocket
+    promises.push((async () => {
+      try { return await bedrockResolver.runOnceSafe() } catch (e) {}
+    })())
+
+    const [vanillaState, gamespyState, bedrockState] = await Promise.all(promises)
+
+    state.raw.vanilla = vanillaState
+    state.raw.gamespy = gamespyState
+    state.raw.bedrock = bedrockState
+
+    if (!vanillaState && !gamespyState && !bedrockState) {
+      throw new Error('No protocols succeeded')
+    }
+
+    // Ordered from least worth to most worth (player names / etc)
+    if (bedrockState) {
+      if (bedrockState.players.length) state.players = bedrockState.players
+    }
+    if (vanillaState) {
+      try {
+        let name = ''
+        const description = vanillaState.raw.description
+        if (typeof description === 'string') {
+          name = description
+        }
+        if (!name && typeof description === 'object' && description.text) {
+          name = description.text
+        }
+        if (!name && typeof description === 'object' && description.extra) {
+          name = description.extra.map(part => part.text).join('')
+        }
+        state.name = name
+      } catch (e) {}
+      if (vanillaState.numplayers) state.numplayers = vanillaState.numplayers
+      if (vanillaState.maxplayers) state.maxplayers = vanillaState.maxplayers
+      if (vanillaState.players.length) state.players = vanillaState.players
+      if (vanillaState.ping) this.registerRtt(vanillaState.ping)
+    }
+    if (gamespyState) {
+      if (gamespyState.name) state.name = gamespyState.name
+      if (gamespyState.numplayers) state.numplayers = gamespyState.numplayers
+      if (gamespyState.maxplayers) state.maxplayers = gamespyState.maxplayers
+      if (gamespyState.players.length) state.players = gamespyState.players
+      else if (gamespyState.numplayers) state.numplayers = gamespyState.numplayers
+      if (gamespyState.ping) this.registerRtt(gamespyState.ping)
+    }
+    if (bedrockState) {
+      if (bedrockState.name) state.name = bedrockState.name
+      if (bedrockState.numplayers) state.numplayers = bedrockState.numplayers
+      if (bedrockState.maxplayers) state.maxplayers = bedrockState.maxplayers
+      if (bedrockState.map) state.map = bedrockState.map
+      if (bedrockState.ping) this.registerRtt(bedrockState.ping)
+    }
+    // remove dupe spaces from name
+    state.name = state.name.replace(/\s+/g, ' ')
+    // remove color codes from name
+    state.name = state.name.replace(/\u00A7./g, '')
+  }
+}

package/protocols/minecraftbedrock.js

@@ -0,0 +1,72 @@
+import Core from './core.js'
+
+export default class minecraftbedrock extends Core {
+  constructor () {
+    super()
+    this.byteorder = 'be'
+  }
+
+  async run (state) {
+    const bufs = [
+      Buffer.from([0x01]), // Message ID, ID_UNCONNECTED_PING
+      Buffer.from('1122334455667788', 'hex'), // Nonce / timestamp
+      Buffer.from('00ffff00fefefefefdfdfdfd12345678', 'hex'), // Magic
+      Buffer.from('0000000000000000', 'hex') // Cliend GUID
+    ]
+
+    return await this.udpSend(Buffer.concat(bufs), buffer => {
+      const reader = this.reader(buffer)
+
+      const messageId = reader.uint(1)
+      if (messageId !== 0x1c) {
+        this.logger.debug('Skipping packet, invalid message id')
+        return
+      }
+
+      const nonce = reader.part(8).toString('hex') // should match the nonce we sent
+      this.logger.debug('Nonce: ' + nonce)
+      if (nonce !== '1122334455667788') {
+        this.logger.debug('Skipping packet, invalid nonce')
+        return
+      }
+
+      // These 8 bytes are identical to the serverId string we receive in decimal below
+      reader.skip(8)
+
+      const magic = reader.part(16).toString('hex')
+      this.logger.debug('Magic value: ' + magic)
+      if (magic !== '00ffff00fefefefefdfdfdfd12345678') {
+        this.logger.debug('Skipping packet, invalid magic')
+        return
+      }
+
+      const statusLen = reader.uint(2)
+      if (reader.remaining() !== statusLen) {
+        throw new Error('Invalid status length: ' + reader.remaining() + ' vs ' + statusLen)
+      }
+
+      const statusStr = reader.rest().toString('utf8')
+      this.logger.debug('Raw status str: ' + statusStr)
+
+      const split = statusStr.split(';')
+      if (split.length < 6) {
+        throw new Error('Missing enough chunks in status str')
+      }
+
+      state.raw.edition = split.shift()
+      state.name = split.shift()
+      state.raw.protocolVersion = split.shift()
+      state.raw.mcVersion = split.shift()
+      state.numplayers = parseInt(split.shift())
+      state.maxplayers = parseInt(split.shift())
+      if (split.length) state.raw.serverId = split.shift()
+      if (split.length) state.map = split.shift()
+      if (split.length) state.raw.gameMode = split.shift()
+      if (split.length) state.raw.nintendoOnly = !!parseInt(split.shift())
+      if (split.length) state.raw.ipv4Port = split.shift()
+      if (split.length) state.raw.ipv6Port = split.shift()
+
+      return true
+    })
+  }
+}

package/protocols/minecraftvanilla.js

@@ -0,0 +1,87 @@
+import Core from './core.js'
+import Varint from 'varint'
+
+export default class minecraftvanilla extends Core {
+  async run (state) {
+    const portBuf = Buffer.alloc(2)
+    portBuf.writeUInt16BE(this.options.port, 0)
+
+    const addressBuf = Buffer.from(this.options.host, 'utf8')
+
+    const bufs = [
+      this.varIntBuffer(47),
+      this.varIntBuffer(addressBuf.length),
+      addressBuf,
+      portBuf,
+      this.varIntBuffer(1)
+    ]
+
+    const outBuffer = Buffer.concat([
+      this.buildPacket(0, Buffer.concat(bufs)),
+      this.buildPacket(0)
+    ])
+
+    const data = await this.withTcp(async socket => {
+      return await this.tcpSend(socket, outBuffer, data => {
+        if (data.length < 10) return
+        const reader = this.reader(data)
+        const length = reader.varint()
+        if (data.length < length) return
+        return reader.rest()
+      })
+    })
+
+    const reader = this.reader(data)
+
+    const packetId = reader.varint()
+    this.logger.debug('Packet ID: ' + packetId)
+
+    const strLen = reader.varint()
+    this.logger.debug('String Length: ' + strLen)
+
+    const rest = reader.rest()
+
+    const str = rest.toString('utf8', 0, strLen)
+    this.logger.debug(str)
+
+    const json = JSON.parse(str.substring(0, strLen))
+    delete json.favicon
+
+    state.raw = json
+    state.maxplayers = json.players.max
+    state.numplayers = json.players.online
+
+    if (json.players.sample) {
+      for (const player of json.players.sample) {
+        state.players.push({
+          id: player.id,
+          name: player.name
+        })
+      }
+    }
+
+    // Better Compatibility Checker mod support
+    let bccJson = {}
+
+    if (rest.length > strLen) {
+      const bccStr = rest.toString('utf8', strLen + 1)
+      bccJson = JSON.parse(bccStr)
+    }
+
+    state.raw.bcc = bccJson
+  }
+
+  varIntBuffer (num) {
+    return Buffer.from(Varint.encode(num))
+  }
+
+  buildPacket (id, data) {
+    if (!data) data = Buffer.from([])
+    const idBuffer = this.varIntBuffer(id)
+    return Buffer.concat([
+      this.varIntBuffer(data.length + idBuffer.length),
+      idBuffer,
+      data
+    ])
+  }
+}