gamespy_query 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in gamespy_query.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/gamespy_query.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gamespy_query/version"
+
+Gem::Specification.new do |s|
+  s.name        = "gamespy_query"
+  s.version     = GamespyQuery::VERSION
+  s.authors     = ["Patrick Roza"]
+  s.email       = ["sb@dev-heaven.net"]
+  s.homepage    = "http://dev-heaven.net"
+  s.summary     = %q{Ruby library for accessing Gamespy services}
+  s.description = %q{}
+
+  s.rubyforge_project = "gamespy_query"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/gamespy_query/base.rb

@@ -0,0 +1,43 @@
+#require 'six/tools'
+require 'action_controller'
+require 'logger'
+
+module GamespyQuery
+  module Tools
+    STR_EMPTY = ""
+  
+    module_function
+    def logger
+      ActionController::Base.logger ||= Logger.new("logger.log")
+    end
+  
+    def debug(&block)
+      logger.debug yield
+    end
+  end
+  
+  class Base
+    def strip_tags(str)
+      # TODO: Strip tags!!
+      str
+    end
+
+    STR_X00 = "\x00"
+    RX_F = /\A\-?[0-9][0-9]*\.[0-9]*\Z/
+    RX_I = /\A\-?[0-9][0-9]*\Z/
+    RX_S = /\A\-?0[0-9]+.*\Z/
+
+    def clean(value) # TODO: Force String, Integer, Float etc?
+      case value
+        when STR_X00
+          nil
+        when RX_F
+          value =~ RX_S ? strip_tags(value) : value.to_f
+        when RX_I
+          value =~ RX_S ? strip_tags(value) : value.to_i
+        else
+          strip_tags(value)
+      end
+    end
+  end
+end

data/lib/gamespy_query/master.rb

@@ -0,0 +1,81 @@
+require_relative 'base'
+
+module GamespyQuery
+  class Master < Base
+    PARAMS = [:hostname, :gamever, :gametype, :gamemode, :numplayers, :maxplayers, :password, :equalModRequired, :mission, :mapname,
+              :mod, :signatures, :verifysignatures, :gamestate, :dedicated, :platform, :sv_battleeye, :language, :difficulty]
+
+    # TODO: Gspy v3 multipacket
+
+    DELIMIT = case RUBY_PLATFORM
+      when /-mingw32$/, /-mswin32$/
+        "\\"
+      else
+        "\\\\"
+    end
+
+    def geoip_path
+      return "" unless defined?(Rails)
+
+      case RUBY_PLATFORM
+      when /-mingw32$/, /-mswin32$/
+        File.join(Rails.root, "config").gsub("/", "\\")
+      else
+        File.join(Rails.root, "config")
+      end
+    end
+
+    def initialize(geo = nil, game = "arma2oapc")
+      @geo, @game = geo, game
+    end
+
+    def process
+      @list = Hash.new
+      self.to_hash(self.read)
+    end
+
+    def read
+      geo = @geo ? @geo : "-Q 11 "
+      unless File.exists?(File.join(geoip_path, "GeoIP.dat"))
+        puts
+        puts "Warning: GeoIP.dat database missing. Can't parse countries. #{GEOIP_PATH}"
+        geo = nil
+      end
+      reply = %x[gslist -p "#{GEOIP_PATH}" -n #{@game} #{geo}-X #{PARAMS.clone.map{|e| "#{DELIMIT}#{e}"}.join("")}]
+      reply.gsub!("\\\\\\", "") if geo
+      reply.split("\n")
+    end
+
+    RX_H = /\A([\.0-9]*):([0-9]*) *\\(.*)/
+    STR_SPLIT = "\\"
+    def to_hash(ar)
+      ar.each_with_index do |entry, index|
+        str = entry[RX_H]
+        next unless str
+        ip, port, content = $1, $2, $3
+        content = content.split(STR_SPLIT)
+        content << "" unless (content.size % 2 == 0)
+        i = 0
+        content.map! do |e|
+          i += 1
+          i % 2 == 0 ? e : clean(e)
+        end
+        addr = "#{ip}:#{port}"
+        if @list.has_key?(addr)
+          e = @list[addr]
+        else
+          e = Hash.new
+          e[:ip] = ip
+          e[:port] = port
+          @list[addr] = e
+        end
+        if e[:gamedata]
+          e[:gamedata].merge!(Hash[*content])
+        else
+          e[:gamedata] = Hash[*content]
+        end
+      end
+      @list
+    end
+  end
+end

data/lib/gamespy_query/parser.rb

@@ -0,0 +1,231 @@
+# encoding: utf-8
+
+=begin
+ GameSpy parser class by Sickboy [Patrick Roza] (sb_at_dev-heaven.net)
+
+ Notes:
+ Gamedata values are not split, Player lists can be (names, teams, scores, deaths), while individual values still are not.
+=end
+
+require_relative 'base'
+
+module GamespyQuery
+  class Parser
+    STR_X0 = "\x00"
+    STR_SPLIT = STR_X0
+    STR_EMPTY = ""
+    STR_ID = "\x00\x04\x05\x06\a"
+
+    RX_SPLITNUM = /^splitnum\x00(.)/i
+    RX_X0_E = /\x00$/
+    RX_PLAYER_HEADER = /\x01/
+    RX_END = /\x00\x02$/
+
+    # packets:
+    #   - Hash, key: packetID, value: packetDATA
+    #   or
+    #   - Array, packetDATA ordered already by packetID
+    def initialize(packets)
+      @packets = case packets
+      when Hash
+        packets.keys.sort.map{|key| packets[key] }
+      when Array
+        packets
+      else
+        raise "Unsupported format"
+      end
+    end
+
+    # Returns Hash with parsed data (:game and :players)
+    # :game => Hash, Key: InfoKey, Value: InfoValue
+    # :players => Hash, Key: InfoType, Value: Array of Values
+    def parse
+      data = {}
+      data[:game] = {} # Key: InfoKey, Value: InfoValue
+      data[:players] = {} # Key: InfoType, Value: Array of Values
+      player_info = false
+      player_data = ""
+
+      # Parse the packets
+      @packets.each do |packet|
+        packet = clean_packet(packet)
+
+        if player_info
+          # Player header was found before, add packet to player_data
+          player_data += packet
+        else
+          if packet =~ RX_PLAYER_HEADER
+            # Found Player header, packet possibly contains partial gamedata too
+            player_info = true
+            packets = packet.split(RX_PLAYER_HEADER, 2)
+
+            # Parse last game_data piece if available
+            data[:game].merge!(parse_game_data(packets[0])) unless packets[0].empty?
+
+            # Collect the player_data if available
+            player_data += packets[1]
+          else
+            # GameData-only
+            data[:game].merge!(parse_game_data(packet))
+          end         
+        end
+      end
+
+      # Parse player_data
+      unless player_data.empty?
+        data[:players] = parse_player_data(player_data)
+      end
+
+      data
+    end
+
+    if RUBY_PLATFORM =~ /mswin32/
+      def get_string(str)
+        System::Text::Encoding.UTF8.GetString(System::Array.of(System::Byte).new(str.bytes.to_a)).to_s
+      end
+    else
+      def get_string(str)
+        #(str + '  ').encode("UTF-8", :invalid => :replace, :undef => :replace)[0..-2]
+        str
+      end
+    end
+
+    def clean_packet(packet)
+      packet = packet.clone
+      packet.sub!(STR_ID, STR_EMPTY) # Cut off the identity
+      packet.sub!(RX_SPLITNUM, STR_EMPTY) # Cut off the splitnum
+      packet.sub!(RX_X0_E, STR_EMPTY) # Cut off last \x00
+      packet.sub!(RX_X0_S, STR_EMPTY) # Cut off first \x00 
+      packet.sub!(RX_END, STR_EMPTY) # Cut off the last \x00\x02
+
+      # Encoding
+      get_string(packet)
+    end
+
+    def parse_game_data(packet)
+      Tools.debug {"Game Parsing #{packet.inspect}"}
+
+      key = nil
+      game_data = {}
+
+      packet.split(STR_SPLIT).each_with_index do |data, index|
+        if (index % 2) == 0
+          key = data
+        else
+          game_data[key] = data
+        end
+      end
+
+      game_data
+    end
+
+    RX_PLAYER_EMPTY = /^player_\x00\x00\x00/
+    RX_PLAYER_INFO = /\x01(team|player|score|deaths)_.(.)/ # \x00 from previous packet, \x01 from continueing player info, (.) - should it overwrite previous value?
+    STR_DEATHS = "deaths_\x00\x00"
+    STR_PLAYER = "player_\x00\x00"
+    STR_TEAM = "team_\x00\x00"
+    STR_SCORE = "score_\x00\x00"
+
+    # TODO: Cleanup
+    def parse_player_data(packet)
+      Tools.debug {"Player Parsing #{packet.inspect}"}
+
+      player_data = {:names => [], :teams => [], :scores => [], :deaths => []} # [[], [], [], []]
+
+      return player_data if packet.nil? || packet.empty?
+
+      data = packet.clone
+      unless data =~ RX_PLAYER_EMPTY
+
+        # Leave out the character or Replace character with special string later used to replace the previous value
+        data.sub!(RX_PLAYER_INFO) { |r|
+          str = $1
+          if $2 == STR_X0
+            # If a proper primary info header of this type was not yet found, replace this secondary header with a proper primary header
+            # This will add the broken info header to the previous info list (name for team, team for score, score for deaths)
+            # However the resulting arrays are limited to num_players, so the info is discared anyway.
+            # TODO: Cleaner implementation!
+            data =~ /(^|[^\x01])#{str}_\x00\x00/ ? STR_X0 : :"#{str}_\x00\x00"
+          else
+            STR_SIX_X0
+          end
+        }
+
+        data, deaths = data.split(STR_DEATHS, 2)
+        data, scores = data.split(STR_SCORE, 2)
+        data, teams = data.split(STR_TEAM, 2)
+        data, names = data.split(STR_PLAYER, 2)
+
+        orig_data = [names, teams, scores, deaths]
+
+        # TODO: Handle seperate score
+        orig_data.each_with_index do |data, i|
+          next if data.nil? || data.empty?
+          str = data.clone
+
+          str.sub!(RX_X0_E, STR_EMPTY) # Remove last \x00
+
+          # Parse the data - \x00 is printed after a non-nil entry, otherwise \x00 means nil (e.g empty team)
+          until str.empty?
+            entry = str[RX_X0_SPEC]
+            player_data[player_data.keys[i]] << entry.sub(STR_X0, STR_EMPTY)
+            str.sub!(entry, STR_EMPTY)
+          end
+          
+          # Search for SIX string to overwrite last entry
+          new_player_data = []
+          overwrite = false
+          player_data[player_data.keys[i]].each do |info|
+            if info == STR_SIX
+              overwrite = true # tag so that the next entry will overwrite the latest entry
+              next # ignore
+            else
+              if overwrite
+                new_player_data[-1] = info # Overwrite latest entry
+                overwrite = false # done the overwrite
+              else
+                #break if new_player_data.size == num_players
+                new_player_data << info # insert entry
+              end
+            end
+          end
+          player_data[player_data.keys[i]] = new_player_data
+        end
+      end
+
+      player_data
+    end
+
+    # Hash of Hashes
+    def self.pretty_player_data(data)
+      player_data = {}
+
+      data[:names].each_with_index do |name, index|
+        player_data[name] = {}
+        player_data[name][:team] = data[:teams][index]
+        player_data[name][:score] = data[:scores][index]
+        player_data[name][:deaths] = data[:deaths][index]
+      end
+
+      player_data
+    end
+
+    # Array of Hashes
+    def self.pretty_player_data2(data)
+      player_data = []
+
+      data[:names].each_with_index do |name, index|
+        player = {}
+
+        player[:name] = name
+        player[:team] = data[:teams][index]
+        player[:score] = data[:scores][index]
+        player[:deaths] = data[:deaths][index]
+
+        player_data << player
+      end
+
+      player_data
+    end
+  end
+end

data/lib/gamespy_query/socket.rb

@@ -0,0 +1,268 @@
+# encoding: utf-8
+# GameSpy query class by Sickboy [Patrick Roza] (sb_at_dev-heaven.net)
+
+require 'yaml'
+require_relative 'base'
+require_relative 'parser'
+
+module GamespyQuery
+  class Socket < Base
+    TIMEOUT = 3
+    MAX_PACKETS = 7
+
+    ID_PACKET = [0x04, 0x05, 0x06, 0x07].pack("c*") # TODO: Randomize
+    BASE_PACKET = [0xFE, 0xFD, 0x00].pack("c*")
+    CHALLENGE_PACKET = [0xFE, 0xFD, 0x09].pack("c*")
+
+    FULL_INFO_PACKET_MP = [0xFF, 0xFF, 0xFF, 0x01].pack("c*")
+    FULL_INFO_PACKET = [0xFF, 0xFF, 0xFF].pack("c*")
+    SERVER_INFO_PACKET = [0xFF, 0x00, 0x00].pack("c*")
+    PLAYER_INFO_PACKET = [0x00, 0xFF, 0x00].pack("c*")
+
+    STR_HOSTNAME = "hostname"
+    STR_PLAYERS = "players"
+    STR_DEATHS = "deaths_\x00\x00"
+    STR_PLAYER = "player_\x00\x00"
+    STR_TEAM = "team_\x00\x00"
+    STR_SCORE = "score_\x00\x00"
+    STR_X0, STR_X1, STR_X2 = "\x00", "\x01", "\x02"
+    SPLIT = STR_X0
+    STR_END = "\x00\x02"
+    STR_EMPTY = Tools::STR_EMPTY
+    STR_BLA = "%c%c%c%c".encode("ASCII-8BIT")
+    STR_GARBAGE = "\x00\x04\x05\x06\a"
+    STR_SIX = "$SIX_OVERWRITE_PREVIOUS$"
+    STR_SIX_X0 = "\x00#{STR_SIX}\x00"
+
+    RX_PLAYER_EMPTY = /^player_\x00\x00\x00/
+    RX_PLAYER_INFO = /\x01(team|player|score|deaths)_.(.)/ # \x00 from previous packet, \x01 from continueing player info, (.) - should it overwrite previous value?
+    RX_X0, RX_X0_S, RX_X0_E = /\x00/, /^\x00/, /\x00$/
+    RX_X0_SPEC = /^\x00|[^\x00]+\x00?/
+
+    RX_NO_CHALLENGE = /0@0$/
+    RX_CHALLENGE = /0@/
+    RX_CHALLENGE2 = /[^0-9\-]/si
+    RX_SPLITNUM = /^splitnum\x00(.)/i
+
+    def create_socket(*params)
+      puts "Creating socket #{params}"
+      _create_socket(*params)
+    end
+
+    def socket_send(*params)
+      puts "Sending socket #{params}"
+      _socket_send(*params)
+    end
+
+    def socket_receive(*params)
+      puts "Receiving socket #{params}"
+      _socket_receive(*params)
+    end
+
+    def socket_close(*params)
+      puts "Closing socket #{params}"
+      _socket_close(*params)
+    end
+
+    def get_string(*params)
+      puts "Getting string #{params}"
+      _get_string(*params)
+    end
+
+    if RUBY_PLATFORM =~ /mswin32/
+      include System::Net
+      include System::Net::Sockets
+
+      def get_string(str)
+        str.map {|e| e.chr}.join  #  begin; System::Text::Encoding.USASCII.GetString(reply[0]).to_s; rescue nil, Exception => e; Tools.log_exception(e); reply[0].map {|e| e.chr}.join; end
+      end
+
+      def _create_socket(host, port)
+        @ip_end_point = IPEndPoint.new(IPAddress.Any, 0)
+        @s = UdpClient.new
+        @s.client.receive_timeout = TIMEOUT * 1000
+        @s.connect(host, port.to_i)
+      end
+
+      def _socket_send(packet)
+        @s.Send(packet, packet.length)
+      end
+
+      def _socket_receive
+        @s.Receive(@ip_end_point)
+      end
+
+      def _socket_close
+        @s.close
+      end
+    else
+      require 'socket'
+      require 'timeout'
+
+      def get_string(str)
+        str
+      end
+
+      def _create_socket(host, port)
+        @s = UDPSocket.new
+        @s.connect(host, port)
+      end
+
+      def _socket_send(packet)
+        @s.puts(packet)
+      end
+
+      def _socket_receive
+        begin
+          Timeout::timeout(TIMEOUT) do
+            @s.recvfrom(4096)
+          end
+        rescue Timeout::Error
+          #socket_close
+          raise TimeoutError
+        end
+      end
+
+      def _socket_close
+        @s.close
+      end
+    end
+
+    attr_accessor :silent
+    def initialize(host, port, silent = nil)
+      @host, @port, @silent = host, port, silent
+    end
+
+    # Supports challenge/response and multi-packet
+    def sync
+      game_data, key, reply = {}, nil, self.fetch
+      return game_data if reply.nil?
+
+      parser = Parser.new(reply)
+      data = parser.parse
+
+      game_data.merge!(data[:game])
+      game_data["players"] = Parser.pretty_player_data2(data[:players]).sort {|a, b| a[:name].downcase <=> b[:name].downcase }
+      
+      game_data["ping"] = @ping unless @ping.nil?
+
+      game_data
+    end
+
+    def fetch
+      data = {}
+      status, reply = nil, nil
+
+      # Prepare socket / endpoint and connect
+      create_socket(@host, @port)
+
+      # Prepare and send challenge request
+      # TODO: Randomize
+      id_packet = ID_PACKET
+      packet = CHALLENGE_PACKET + id_packet
+      Tools.debug{"Sending Challenge (#{packet.length}): #{packet.inspect}"}
+      sent = Time.now
+
+      socket_send(packet)
+
+      pings = []
+
+      challenge, received = nil, nil
+      begin
+        # By default, Blocks until a message returns on this socket from a remote host.
+        reply = socket_receive
+        received = Time.now
+        # TODO: Improve ping test?
+        ping = received - sent
+        pings << ping
+        Tools.debug {"PingTest: #{ping}"}
+        challenge = reply[0]
+      rescue nil, Exception => e  # Cannot use ensure as we want to keep the socket open :P
+        socket_close
+        raise e
+      end
+      return nil if challenge.nil? || challenge.empty?
+
+      # Prepare challenge response, if needed
+      str = get_string(challenge)
+      Tools.debug{"Received challenge response (#{str.length}): #{str.inspect}"}
+      need_challenge = !(str.sub(STR_X0, STR_EMPTY) =~ RX_NO_CHALLENGE)
+
+      if need_challenge
+        Tools.debug {"Needs challenge!"}
+        str = str.sub(RX_CHALLENGE, STR_EMPTY).gsub(RX_CHALLENGE2, STR_EMPTY).to_i
+        challenge_packet = sprintf(STR_BLA, handle_chr(str >> 24), handle_chr(str >> 16), handle_chr(str >> 8), handle_chr(str >> 0))
+      end
+
+      # Prepare and send info request packet
+      packet = need_challenge ? BASE_PACKET + id_packet + challenge_packet + FULL_INFO_PACKET_MP : BASE_PACKET + id_packet + FULL_INFO_PACKET_MP
+      Tools.debug{"Sending:\n#{packet.inspect}"}
+      sent = Time.now
+      socket_send(packet)
+
+      # Receive response to info request packet, up to 7 packets of information, each limited to 1400 bytes
+      max_packets = MAX_PACKETS # Default max
+      begin
+        # In case some server info didn't fit in a single packet, there will be no proper END OF DATA signal
+        # So we manually quit after reaching MAX_PACKETS.
+        until data.size >= max_packets
+          reply = socket_receive
+
+          if data.empty?
+            received = Time.now
+            ping = received - sent
+            pings << ping
+            Tools.debug {"PingTest: #{ping}"}
+          end
+          index = 0
+
+          game_data = get_string(reply[0])
+          Tools.debug {"Received (#{data.size + 1}):\n\n#{game_data.inspect}\n\n#{game_data}\n\n"}
+
+          if game_data.sub(STR_GARBAGE, STR_EMPTY)[RX_SPLITNUM]
+            splitnum = $1
+            flag = splitnum.unpack("C")[0]
+            index = (flag & 127).to_i
+            last = flag & 0x80 > 0
+            # Data could be received out of order, use the "index" id when "last" flag is true, to determine total packet_count
+            max_packets = index + 1 if last # update the max
+            Tools.debug {"Splitnum: #{splitnum.inspect} (#{splitnum}) (#{flag}, #{index}, #{last}) Max: #{max_packets}"}
+          else
+            max_packets = 1
+          end
+          data[index] = game_data #.sub(RX_X0_S, STR_EMPTY) # Cut off first \x00 from package
+        end
+      ensure
+        socket_close
+      end
+
+      pings.map!{|ping| (ping * 1000).round}
+      pings_c = 0
+      pings.each { |ping| pings_c += ping }
+
+      ping = pings_c / pings.size
+      Tools.debug{"Gamespy pings: #{pings}, #{ping}"}
+
+      return nil if data.keys.empty?
+      @ping = ping
+      data.each_pair {|k, d| Tools.debug {"GSPY Infos: #{k} #{d.size}"} } unless @silent || !$debug
+
+      data
+    end
+
+    def handle_chr(number)
+      number = ((number % 256)+256) if number < 0
+      number = number % 256 if number > 255
+      number
+    end
+  end
+end
+
+if $0 == __FILE__
+  host = ARGV[0]
+  port = ARGV[1]
+  g = Six::Query::Gamespy.new(host, port)
+  r = g.sync
+  exit unless r
+  puts r.to_yaml
+end

data/lib/gamespy_query/version.rb

@@ -0,0 +1,3 @@
+module GamespyQuery
+  VERSION = "0.0.1"
+end

data/lib/gamespy_query.rb

@@ -0,0 +1,8 @@
+require "gamespy_query/version"
+require "gamespy_query/base"
+require "gamespy_query/socket"
+require "gamespy_query/master"
+
+module GamespyQuery
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: gamespy_query
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Patrick Roza
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-06 00:00:00.000000000 Z
+dependencies: []
+description: ''
+email:
+- sb@dev-heaven.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- gamespy_query.gemspec
+- lib/gamespy_query.rb
+- lib/gamespy_query/base.rb
+- lib/gamespy_query/master.rb
+- lib/gamespy_query/parser.rb
+- lib/gamespy_query/socket.rb
+- lib/gamespy_query/version.rb
+homepage: http://dev-heaven.net
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: gamespy_query
+rubygems_version: 1.8.13
+signing_key: 
+specification_version: 3
+summary: Ruby library for accessing Gamespy services
+test_files: []