steam-condenser 0.8.0

data/lib/steam/packets/s2a_info_base_packet.rb

@@ -0,0 +1,29 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+
+require "abstract_class"
+require "steam/packets/steam_packet"
+
+# The S2A_INFO_BasePacket class represents the response to a A2S_INFO
+# request send to the server.
+class S2A_INFO_BasePacket < SteamPacket
+  
+  include AbstractClass
+  
+  # Creates a S2A_INFO[...] response object based on the data received.
+  def initialize(header, data)
+    super header, data
+  end
+  
+  # Returns the hash containing information on the server
+  public
+  def get_info_hash
+    return Hash[
+      *instance_variables.map { |var|
+        if var != "@content_data" && var != "@header_data"
+          [var[1..-1], instance_variable_get(var)]
+        end
+      }.compact.flatten
+    ]
+  end
+end

data/lib/steam/packets/s2a_info_detailed_packet.rb

@@ -0,0 +1,50 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2008-2009, Sebastian Staudt
+
+require "steam/packets/s2a_info_base_packet"
+
+# The S2A_INFO_DETAILED_Packet class represents the response to a A2S_INFO
+# request send to a GoldSrc server.
+# This is deprecated by 10/24/2008 for GoldSrc servers. They use the same
+# format as Source servers (S2A_INFO2) now.
+class S2A_INFO_DETAILED_Packet < S2A_INFO_BasePacket
+  
+  # Creates a S2A_INFO_DETAILED response object based on the data received.
+  def initialize(data)
+    super SteamPacket::S2A_INFO_DETAILED_HEADER, data
+
+    @game_ip = @content_data.get_string
+    @server_name = @content_data.get_string
+    @map_name = @content_data.get_string
+    @game_directory = @content_data.get_string
+    @game_description = @content_data.get_string
+    @number_of_players = @content_data.get_byte
+    @max_players = @content_data.get_byte
+    @network_version = @content_data.get_byte
+    @dedicated = @content_data.get_byte.chr
+    @operating_system = @content_data.get_byte.chr
+    @password_needed = @content_data.get_byte == 1
+    @is_mod = @content_data.get_byte == 1
+    
+    if @is_mod
+      @mod_info = Hash.new
+      @mod_info["url_info"] = @content_data.get_string
+      @mod_info["url_dl"] = @content_data.get_string
+      @content_data.get_byte
+      if @content_data.remaining == 12
+        @mod_info["mod_version"] = @content_data.get_long
+        @mod_info["mod_size"] = @content_data.get_long
+        @mod_info["sv_only"] = @content_data.get_byte == 1
+        @mod_info["cl_dll"] = @content_data.get_byte == 1
+        @secure = @content_data.get_byte == 1
+        @number_of_bots = @content_data.get_byte
+      end
+    else
+      @secure = @content_data.get_byte == 1
+      @number_of_bots = @content_data.get_byte
+    end
+  end
+  
+end

data/lib/steam/packets/s2a_player_packet.rb

@@ -0,0 +1,32 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2008-2009, Sebastian Staudt
+
+require "steam/packets/steam_packet"
+
+# The S2A_PLAYER_Packet class represents the response to a A2S_PLAYER
+# request send to the server.
+class S2A_PLAYER_Packet < SteamPacket
+
+  attr_reader :player_hash
+  
+  # Creates a S2A_PLAYER response object based on the data received.
+  def initialize(content_data)
+    if content_data == nil
+      raise Exception.new("Wrong formatted S2A_PLAYER packet.")
+    end
+    
+    super SteamPacket::S2A_PLAYER_HEADER, content_data
+
+    # Ignore player count
+    @content_data.get_byte
+    @player_hash = {}
+
+    while @content_data.remaining > 0
+      player_data = @content_data.get_byte, @content_data.get_string, @content_data.get_signed_long, @content_data.get_float
+      @player_hash[player_data[1]] = SteamPlayer.new(*player_data[0..3])
+    end
+  end
+
+end

data/lib/steam/packets/s2a_rules_packet.rb

@@ -0,0 +1,33 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2008, Sebastian Staudt
+#
+# $Id$
+
+require "steam/packets/steam_packet"
+
+# The S2A_RULES_Packet class represents the response to a A2S_RULES
+# request send to the server.
+class S2A_RULES_Packet < SteamPacket
+  
+  # Creates a S2A_RULES response object based on the data received.
+  def initialize(content_data)
+    if content_data == nil
+      raise Exception.new("Wrong formatted A2A_RULES response packet.")
+    end
+    
+    super SteamPacket::S2A_RULES_HEADER, content_data
+    
+    @rules_hash = Hash.new @content_data.get_short
+
+    while @content_data.remaining > 0
+      @rules_hash[@content_data.get_string] = @content_data.get_string
+    end
+  end
+
+  # Returns the hash containing the server rules
+  def get_rules_hash
+    return @rules_hash
+  end
+end

data/lib/steam/packets/s2c_challenge_packet.rb

@@ -0,0 +1,23 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2008, Sebastian Staudt
+#
+# $Id$
+
+require "steam/packets/steam_packet"
+
+# The S2C_CHALLENGE_Packet class represents the response
+# to a A2S_SERVERQUERY_GETCHALLENGE request send to the server.
+class S2C_CHALLENGE_Packet < SteamPacket
+  
+  # Creates a AS2C_CHALLENGE response object based on the data received.
+  def initialize(challenge_number)
+    super S2C_CHALLENGE_HEADER, challenge_number
+  end
+  
+  # Returns the challenge number received from the server
+  def get_challenge_number
+    return @content_data.rewind.get_long
+  end
+end

data/lib/steam/packets/steam_packet.rb

@@ -0,0 +1,48 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2008, Sebastian Staudt
+#
+# $Id$
+
+# This class represents a packet used by the Source query protocol
+class SteamPacket
+  S2A_INFO_DETAILED_HEADER = 0x6D
+  A2S_INFO_HEADER = 0x54
+  S2A_INFO2_HEADER = 0x49
+  A2A_PING_HEADER = 0x69
+  A2A_ACK_HEADER = 0x6A
+  A2S_PLAYER_HEADER = 0x55
+  S2A_PLAYER_HEADER = 0x44
+  A2S_RULES_HEADER = 0x56
+  S2A_RULES_HEADER = 0x45
+  A2S_SERVERQUERY_GETCHALLENGE_HEADER = 0x57
+  S2C_CHALLENGE_HEADER = 0x41
+  A2M_GET_SERVERS_BATCH2_HEADER = 0x31
+  M2A_SERVER_BATCH_HEADER = 0x66
+  S2C_CONNREJECT_HEADER = 0x39
+  RCON_GOLDSRC_CHALLENGE_HEADER = 0x63
+  RCON_GOLDSRC_NO_CHALLENGE_HEADER = 0x39
+  RCON_GOLDSRC_RESPONSE_HEADER = 0x6c
+
+  # Creates a new SteamPacket object with given header and content data
+  def initialize(header_data, content_data = "")
+    @content_data = ByteBuffer.new content_data
+    @header_data = header_data
+  end
+  
+  # Returns a packed string representing the packet's data
+  #
+  # TODO Has to automatically split packets greater than 1400 bytes
+  def to_s
+    packet_data = [0xFF, 0xFF, 0xFF].pack("ccc")
+    
+    unless @split_packet
+      packet_data << [0xFF].pack("c")
+    else
+      packet_data << [0xFE].pack("c")
+    end
+    
+    return packet_data << [@header_data, @content_data.array].pack("ca*")
+  end    
+end

data/lib/steam/packets/steam_packet_factory.rb

@@ -0,0 +1,90 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2008-2009, Sebastian Staudt
+
+require 'zlib'
+
+require "abstract_class"
+require "steam/packets/s2a_info_detailed_packet"
+require "steam/packets/a2s_info_packet"
+require "steam/packets/s2a_info2_packet"
+require "steam/packets/a2a_ping_packet"
+require "steam/packets/a2a_ack_packet"
+require "steam/packets/a2s_player_packet"
+require "steam/packets/s2a_player_packet"
+require "steam/packets/a2s_rules_packet"
+require "steam/packets/s2a_rules_packet"
+require "steam/packets/a2s_serverquery_getchallenge_packet"
+require "steam/packets/s2c_challenge_packet"
+require "steam/packets/a2m_get_servers_batch2_packet"
+require "steam/packets/m2a_server_batch_packet"
+require "steam/packets/rcon/rcon_goldsrc_response"
+
+class SteamPacketFactory
+  
+  include AbstractClass
+  
+  # Creates a new packet object based on the header byte of the given raw data
+  def self.get_packet_from_data(raw_data)
+    header = raw_data[0].to_i;
+    data = raw_data[1..-1];
+    
+    case header
+      when SteamPacket::S2A_INFO_DETAILED_HEADER
+        return S2A_INFO_DETAILED_Packet.new(data)
+      when SteamPacket::A2S_INFO_HEADER
+        return A2S_INFO_Packet.new;
+      when SteamPacket::S2A_INFO2_HEADER
+        return S2A_INFO2_Packet.new(data)
+      when SteamPacket::A2A_PING_HEADER
+        return A2A_PING_Packet.new
+      when SteamPacket::A2A_ACK_HEADER
+        return A2A_ACK_Packet.new(data)
+      when SteamPacket::A2S_PLAYER_HEADER
+        return A2S_PLAYER_Packet.new
+      when SteamPacket::S2A_PLAYER_HEADER
+        return S2A_PLAYER_Packet.new(data)
+      when SteamPacket::A2S_RULES_HEADER
+        return A2S_RULES_Packet
+      when SteamPacket::S2A_RULES_HEADER
+        return S2A_RULES_Packet.new(data)
+      when SteamPacket::A2S_SERVERQUERY_GETCHALLENGE_HEADER
+        return A2S_SERVERQUERY_GETCHALLENGE_Packet.new
+      when SteamPacket::S2C_CHALLENGE_HEADER
+        return S2C_CHALLENGE_Packet.new(data)
+      when SteamPacket::A2M_GET_SERVERS_BATCH2_HEADER
+        return A2M_GET_SERVERS_BATCH2.new(data)
+      when SteamPacket::M2A_SERVER_BATCH_HEADER
+        return M2A_SERVER_BATCH_Packet.new(data)
+      when SteamPacket::RCON_GOLDSRC_CHALLENGE_HEADER,
+           SteamPacket::RCON_GOLDSRC_NO_CHALLENGE_HEADER,
+           SteamPacket::RCON_GOLDSRC_RESPONSE_HEADER
+        return RCONGoldSrcResponse.new(data)
+      else
+        raise Exception.new("Unknown packet with header 0x#{header.to_s 16} received.")
+    end
+  end
+  
+  def self.reassemble_packet(split_packets, is_compressed = false, packet_checksum = 0)
+    packet_data = split_packets.join ""
+    
+    if is_compressed
+      begin
+        require 'bz2'
+        packet_data = BZ2.uncompress(packet_data)
+      rescue LoadError
+        raise SteamCondenserException.new("You need to install the libbzip2 interface for Ruby.")
+      end
+      
+      if Zlib.crc32(packet_data) != packet_checksum
+        raise PacketFormatException.new("CRC32 checksum mismatch of uncompressed packet data.")
+      end
+    end
+    
+    packet_data = packet_data[4..-1]
+    
+    return self.get_packet_from_data(packet_data)
+  end
+  
+end

data/lib/steam/servers/game_server.rb

@@ -0,0 +1,222 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2008-2009, Sebastian Staudt
+
+require "abstract_class"
+require "exceptions/steam_condenser_exception"
+require "steam/steam_player"
+require "steam/packets/a2s_info_packet"
+require "steam/packets/a2a_ping_packet"
+require "steam/packets/a2s_player_packet"
+require "steam/packets/a2s_rules_packet"
+require "steam/packets/a2s_serverquery_getchallenge_packet"
+require "steam/packets/s2a_info_base_packet"
+require "steam/packets/s2a_player_packet"
+require "steam/packets/s2a_rules_packet"
+require "steam/packets/s2c_challenge_packet"
+
+class GameServer
+  
+  include AbstractClass
+  
+  REQUEST_CHALLENGE = 0
+  REQUEST_INFO = 1
+  REQUEST_PLAYER = 2
+  REQUEST_RULES = 3
+  
+  # Returns the last measured response time of this server
+  #
+  # If there's no data, update_ping is called to measure the current response
+  # time of the server.
+  #
+  # Whenever you want to get a new value for the ping time call update_ping.
+  def get_ping
+    if @ping == nil
+      self.update_ping
+    end
+    return @ping
+  end
+  
+  # Returns an array of the player's currently playing on this server.
+  #
+  # If there's no data, update_player_info is called to get the current list of
+  # players.
+  #  
+  # As the players and their scores change quite often be sure to update this
+  # list regularly by calling update_player_info.
+  def get_players(rcon_password = nil)
+    if @player_hash == nil
+      self.update_player_info(rcon_password)
+    end
+    
+    return @player_hash
+  end
+  
+  # Returns a hash of the settings applied on the server. These settings are
+  # also called rules.
+  # The hash has the format of +rule_name+ => +rule_value+
+  # 
+  # If there's no data, update_rules_info is called to get the current list of
+  # rules.
+  #
+  # As the rules usually don't change often, there's almost no need to update
+  # this hash. But if you need to, you can achieve this by calling
+  # update_rules_info.
+  def get_rules
+    if @rules_hash == nil
+      self.update_rules_info
+    end
+    
+    return @rules_hash
+  end
+  
+  # Returns a hash with basic information on the server.
+  # 
+  # If there's no data, update_server_info is called to get up-to-date
+  # information.
+  #
+  # The server information usually only changes on map change and when players
+  # join or leave. As the latter changes can be monitored by calling
+  # update_player_info, there's no need to call update_server_info very often.
+  def get_server_info
+    if @info_hash == nil
+      self.update_server_info
+    end
+    
+    return @info_hash
+  end
+  
+  def handle_response_for_request(request_type, repeat_on_failure = true)
+    begin
+      case request_type
+        when GameServer::REQUEST_CHALLENGE then
+          request_packet = A2S_SERVERQUERY_GETCHALLENGE_Packet.new
+          expected_response = S2C_CHALLENGE_Packet
+        when GameServer::REQUEST_INFO then
+          request_packet = A2S_INFO_Packet.new
+          expected_response = S2A_INFO_BasePacket
+        when GameServer::REQUEST_PLAYER then
+          request_packet = A2S_PLAYER_Packet.new(@challenge_number)
+          expected_response = S2A_PLAYER_Packet
+        when GameServer::REQUEST_RULES then
+          request_packet = A2S_RULES_Packet.new(@challenge_number)
+          expected_response = S2A_RULES_Packet
+        else
+          raise SteamCondenserException.new("Called with wrong request type.")
+      end
+      
+      self.send_request request_packet
+      response_packet = self.get_reply
+
+      if response_packet.kind_of? S2A_INFO_BasePacket
+        @info_hash = response_packet.get_info_hash
+      elsif response_packet.kind_of? S2A_PLAYER_Packet
+        @player_hash = response_packet.player_hash
+      elsif response_packet.kind_of? S2A_RULES_Packet
+        @rules_hash = response_packet.get_rules_hash
+      elsif response_packet.kind_of? S2C_CHALLENGE_Packet
+        @challenge_number = response_packet.get_challenge_number
+      else
+        raise SteamCondenserException.new("Response of type #{response_packet.class} cannot be handled by this method.")
+      end
+      
+      unless response_packet.kind_of? expected_response
+        warn "Expected #{expected_response}, got #{response_packet.class}."
+        self.handle_response_for_request(request_type, false) if repeat_on_failure
+      end
+    rescue TimeoutException
+      warn "Expected #{expected_response}, but timed out."
+    end
+  end
+  
+  def init
+    self.update_ping
+    self.update_server_info
+    self.update_challenge_number
+  end
+
+  def update_player_info(rcon_password = nil)
+    self.handle_response_for_request GameServer::REQUEST_PLAYER
+
+    unless rcon_password.nil? or @player_hash.empty?
+      rcon_auth(rcon_password)
+      players = rcon_exec('status').split("\n")[7..-1]
+      if is_a? GoldSrcServer
+        players.pop
+      end
+
+      players.each do |player|
+        player_data = split_player_status(player)
+        @player_hash[player_data[1]].add_info(*player_data)
+      end
+    end
+  end
+
+  def update_rules_info
+    self.handle_response_for_request GameServer::REQUEST_RULES
+  end
+  
+  def update_server_info
+    self.handle_response_for_request GameServer::REQUEST_INFO
+  end
+  
+  def update_challenge_number
+    self.handle_response_for_request GameServer::REQUEST_CHALLENGE
+  end
+ 
+  def update_ping
+    self.send_request A2A_PING_Packet.new
+    start_time = Time.now
+    self.get_reply
+    end_time = Time.now
+    return @ping = (end_time - start_time) * 1000
+  end
+  
+  # Checks whether the listening port number of the server is in a valid range 
+  def initialize(port_number = 27015)
+    unless port_number.to_i > 0 and port_number.to_i < 65536
+      raise ArgumentError.new("The listening port of the server has to be a number greater than 0 and less than 65536.")
+    end
+  end
+  
+  def to_s
+    return_string = ""
+    
+    return_string << "Ping: #{@ping}\n"
+    return_string << "Challenge number: #{@challenge_number}\n"
+    
+    if @info_hash != nil
+      return_string << "Info:\n"
+      @info_hash.each do |key, value|
+        return_string << "  #{key}: #{value.inspect}\n"
+      end
+    end
+    
+    if @player_hash != nil
+      return_string << "Players:\n"
+      @player_hash.each do |player|
+        return_string << "  #{player}\n"
+      end
+    end
+    
+    if @rules_hash != nil
+      return_string << "Rules:\n"
+      @rules_hash.each do |key, value|
+        return_string << "  #{key}: #{value}\n"
+      end
+    end
+    
+    return return_string
+  end
+
+  protected
+
+  def get_reply
+    @socket.get_reply
+  end
+  
+  def send_request packet
+    @socket.send packet
+  end
+end