steam-condenser 1.3.8.1 → 1.3.9

data/pkg/steam-condenser-1.3.8.1/lib/steam/packets/steam_packet_factory.rb

@@ -0,0 +1,113 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2008-2013, Sebastian Staudt
+
+require 'zlib'
+
+require 'errors/packet_format_error'
+require 'steam/packets/s2a_info_detailed_packet'
+require 'steam/packets/a2s_info_packet'
+require 'steam/packets/s2a_info2_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/m2c_isvalidmd5_packet'
+require 'steam/packets/m2s_requestrestart_packet'
+require 'steam/packets/s2a_logstring_packet'
+require 'steam/packets/rcon/rcon_goldsrc_response'
+
+# This module provides functionality to handle raw packet data, including
+# data split into several UDP / TCP packets and BZIP2 compressed data. It's the
+# main utility to transform data bytes into packet objects.
+#
+# @author Sebastian Staudt
+# @see SteamPacket
+module SteamPacketFactory
+
+  # Creates a new packet object based on the header byte of the given raw data
+  #
+  # @param [String] raw_data The raw data of the packet
+  # @raise [SteamCondenserError] if the packet header is not recognized
+  # @return [SteamPacket] The packet object generated from the packet data
+  def self.packet_from_data(raw_data)
+    header = raw_data[0].ord
+    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::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_Packet.new(data)
+      when SteamPacket::M2A_SERVER_BATCH_HEADER
+        return M2A_SERVER_BATCH_Packet.new(data)
+      when SteamPacket::M2C_ISVALIDMD5_HEADER
+        return M2C_ISVALIDMD5_Packet.new(data)
+      when SteamPacket::M2S_REQUESTRESTART_HEADER
+        return M2S_REQUESTRESTART_Packet.new(data)
+      when SteamPacket::RCON_GOLDSRC_CHALLENGE_HEADER,
+           SteamPacket::RCON_GOLDSRC_NO_CHALLENGE_HEADER,
+           SteamPacket::RCON_GOLDSRC_RESPONSE_HEADER
+        return RCONGoldSrcResponse.new(data)
+      when SteamPacket::S2A_LOGSTRING_HEADER
+        return S2A_LOGSTRING_Packet.new(data)
+      else
+        raise PacketFormatError, "Unknown packet with header 0x#{header.to_s(16)} received."
+    end
+  end
+
+  # Reassembles the data of a split and/or compressed packet into a single
+  # packet object
+  #
+  # @param [Array<String>] split_packets An array of packet data
+  # @param [Boolean] is_compressed whether the data of this packet is
+  #        compressed
+  # @param [Fixnum] packet_checksum The CRC32 checksum of the decompressed
+  #        packet data
+  # @raise [SteamCondenserError] if the bz2 gem is not installed
+  # @raise [PacketFormatError] if the calculated CRC32 checksum does not match
+  #        the expected value
+  # @return [SteamPacket] The reassembled packet
+  # @see packet_from_data
+  def self.reassemble_packet(split_packets, is_compressed = false, packet_checksum = 0)
+    packet_data = split_packets.join ''
+
+    if is_compressed
+      begin
+        require 'bzip2-ruby'
+      rescue LoadError
+        raise SteamCondenserError, 'The "bzip2-ruby" gem is not installed. Please install it, if you want to query Source servers sending compressed packets.'
+      end
+
+      packet_data = Bzip2.decompress packet_data
+
+      unless Zlib.crc32(packet_data) == packet_checksum
+        raise PacketFormatError, 'CRC32 checksum mismatch of uncompressed packet data.'
+      end
+    end
+
+    packet_from_data packet_data[4..-1]
+  end
+
+end

data/pkg/steam-condenser-1.3.8.1/lib/steam/servers/game_server.rb

@@ -0,0 +1,393 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2008-2013, Sebastian Staudt
+
+require 'errors/steam_condenser_error'
+require 'errors/timeout_error'
+require 'steam/steam_player'
+require 'steam/packets/a2s_info_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'
+require 'steam/servers/server'
+
+# This module is included by classes representing different game server
+# implementations and provides the basic functionality to communicate with
+# them using the common query protocol
+#
+# @author Sebastian Staudt
+module GameServer
+
+  include Server
+
+  # Parses the player attribute names supplied by `rcon status`
+  #
+  # @param [String] status_header The header line provided by `rcon status`
+  # @return [Array<Symbol>] Split player attribute names
+  # @see .split_player_status
+  def self.player_status_attributes(status_header)
+    status_header.split.map do |attribute|
+      case attribute
+        when 'connected'
+          :time
+        when 'frag'
+          :score
+        else
+          attribute.to_sym
+      end
+    end
+  end
+
+  # Splits the player status obtained with `rcon status`
+  #
+  # @param [Array<Symbol>] attributes The attribute names
+  # @param [String] player_status The status line of a single player
+  # @return [Hash<Symbol, String>] The attributes with the corresponding values
+  #         for this player
+  # @see .player_status_attributes
+  def self.split_player_status(attributes, player_status)
+    player_status.sub! /^\d+ +/, '' if attributes.first != :userid
+
+    first_quote = player_status.index '"'
+    last_quote  = player_status.rindex '"'
+    data = [
+      player_status[0, first_quote],
+      player_status[first_quote + 1..last_quote - 1],
+      player_status[last_quote + 1..-1]
+    ]
+    data = [ data[0].split, data[1], data[2].split ]
+    data.flatten!
+
+    if attributes.size > data.size && attributes.include?(:state)
+      data.insert 3, nil, nil, nil
+    elsif attributes.size < data.size
+      data.delete_at 1
+    end
+
+    player_data = {}
+    data.each_index do |i|
+      player_data[attributes[i]] = data[i]
+    end
+
+    player_data
+  end
+
+  # Creates a new instance of a game server object
+  #
+  # @param [String] address Either an IP address, a DNS name or one of them
+  #        combined with the port number. If a port number is given, e.g.
+  #        'server.example.com:27016' it will override the second argument.
+  # @param [Fixnum] port The port the server is listening on
+  # @raise [SteamCondenserError] if an host name cannot be resolved
+  def initialize(address, port = 27015)
+    super
+
+    @rcon_authenticated = false
+  end
+
+  # Returns the last measured response time of this server
+  #
+  # If the latency hasn't been measured yet, it is done when calling this
+  # method for the first time.
+  #
+  # If this information is vital to you, be sure to call {#update_ping}
+  # regularly to stay up-to-date.
+  #
+  # @return [Fixnum] The latency of this server in milliseconds
+  # @see #update_ping
+  def ping
+    update_ping if @ping.nil?
+    @ping
+  end
+
+  # Returns a list of players currently playing on this server
+  #
+  # If the players haven't been fetched yet, it is done when calling this
+  # method for the first time.
+  #
+  # As the players and their scores change quite often be sure to update this
+  # list regularly by calling {#update_players} if you rely on this
+  # information.
+  #
+  # @param [String] rcon_password The RCON password of this server may be
+  #        provided to gather more detailed information on the players, like
+  #        STEAM_IDs.
+  # @return [Hash] The players on this server
+  # @see update_players
+  def players(rcon_password = nil)
+    update_players(rcon_password) if @player_hash.nil?
+    @player_hash
+  end
+
+  # Authenticates the connection for RCON communication with the server
+  #
+  # @abstract Must be be implemented by including classes to handle the
+  #           authentication
+  # @param [String] password The RCON password of the server
+  # @return [Boolean] whether the authentication was successful
+  # @see #rcon_exec
+  def rcon_auth(password)
+    raise NotImplementedError
+  end
+
+  # Returns whether the RCON connection to this server is already authenticated
+  #
+  # @return [Boolean] `true` if the RCON connection is authenticated
+  # @see #rcon_auth
+  def rcon_authenticated?
+    @rcon_authenticated
+  end
+
+  # Remotely executes a command on the server via RCON
+  #
+  # @abstract Must be be implemented by including classes to handle the command
+  #           execution
+  # @param [String] command The command to execute on the server
+  # @return [String] The output of the executed command
+  # @see #rcon_auth
+  def rcon_exec(command)
+    raise NotImplementedError
+  end
+
+  # Returns the settings applied on the server. These settings are also called
+  # rules.
+  #
+  # If the rules haven't been fetched yet, it is done when calling this method
+  # for the first time.
+  #
+  # 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}.
+  #
+  # @return [Hash<String, String>] The currently active server rules
+  # @see #update_rules
+  def rules
+    update_rules if @rules_hash.nil?
+    @rules_hash
+  end
+
+  # Returns a hash with basic information on the server.
+  #
+  # If the server information haven't been fetched yet, it is done when
+  # calling this method for the first time.
+  #
+  # 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_players}, there's no need to call {#update_server_info} very
+  # often.
+  #
+  # @return [Hash] Server attributes with their values
+  # @see #update_server_info
+  def server_info
+    update_server_info if @info_hash.nil?
+    @info_hash
+  end
+
+  # Sends the specified request to the server and handles the returned response
+  #
+  # Depending on the given request type this will fill the various data
+  # attributes of the server object.
+  #
+  # @param [Symbol] request_type The type of request to send to the server
+  # @param [Boolean] repeat_on_failure Whether the request should be repeated,
+  #        if the replied packet isn't expected. This is useful to handle
+  #        missing challenge numbers, which will be automatically filled in,
+  #        although not requested explicitly.
+  # @raise [SteamCondenserError] if either the request type or the response
+  #        packet is not known
+  def handle_response_for_request(request_type, repeat_on_failure = true)
+    case request_type
+      when :challenge then
+        request_packet = A2S_PLAYER_Packet.new
+        expected_response = S2C_CHALLENGE_Packet
+      when :info then
+        request_packet = A2S_INFO_Packet.new
+        expected_response = S2A_INFO_BasePacket
+      when :players then
+        request_packet = A2S_PLAYER_Packet.new(@challenge_number)
+        expected_response = S2A_PLAYER_Packet
+      when :rules then
+        request_packet = A2S_RULES_Packet.new(@challenge_number)
+        expected_response = S2A_RULES_Packet
+      else
+        raise SteamCondenserError, 'Called with wrong request type.'
+    end
+
+    send_request request_packet
+    response_packet = reply
+
+    if response_packet.kind_of? S2A_INFO_BasePacket
+      @info_hash = response_packet.info
+    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.rules_hash
+    elsif response_packet.kind_of? S2C_CHALLENGE_Packet
+      @challenge_number = response_packet.challenge_number
+    else
+      raise SteamCondenserError, "Response of type #{response_packet.class} cannot be handled by this method."
+    end
+
+    unless response_packet.kind_of? expected_response
+      puts "Expected #{expected_response}, got #{response_packet.class}." if $DEBUG
+      handle_response_for_request(request_type, false) if repeat_on_failure
+    end
+  end
+
+  # Initializes this server object with basic information
+  #
+  # @see #update_challenge_number
+  # @see #update_ping
+  # @see #update_server_info
+  def init
+    update_ping
+    update_server_info
+    update_challenge_number
+  end
+
+  # Sends a A2S_PLAYERS request to the server and updates the players' data for
+  # this server
+  #
+  # As the players and their scores change quite often be sure to update this
+  # list regularly by calling this method if you rely on this
+  # information.
+  #
+  # @param [String] rcon_password The RCON password of this server may be
+  #        provided to gather more detailed information on the players, like
+  #        STEAM_IDs.
+  # @see #handle_response_for_request
+  # @see #players
+  def update_players(rcon_password = nil)
+    handle_response_for_request :players
+
+    unless @rcon_authenticated
+      return if rcon_password.nil?
+      rcon_auth rcon_password
+    end
+
+    players = rcon_exec('status').lines.select do |line|
+      line.start_with?('#') && line != "#end\n"
+    end.map do |line|
+      line[1..-1].strip
+    end
+    attributes = GameServer.player_status_attributes players.shift
+
+    players.each do |player|
+      player_data = GameServer.split_player_status(attributes, player)
+      player_name = player_data[:name]
+      if @player_hash.key? player_name
+        @player_hash[player_name].add_info player_data
+      end
+    end
+  end
+
+  # Sends a A2S_RULES request to the server and updates the rules of this
+  # server
+  #
+  # 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 this method.
+  #
+  # @see #handle_response_for_request
+  # @see #rules
+  def update_rules
+    handle_response_for_request :rules
+  end
+
+  # Sends a A2S_INFO request to the server and updates this server's basic
+  # 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_players}, there's no need to call this method very often.
+  #
+  # @see #handle_response_for_request
+  # @see #server_info
+  def update_server_info
+    handle_response_for_request :info
+  end
+
+  # Sends a A2S_SERVERQUERY_GETCHALLENGE request to the server and updates the
+  # challenge number used to communicate with this server
+  #
+  # There's usually no need to call this method explicitly, because
+  # {#handle_response_for_request} will automatically get the challenge number
+  # when the server assigns a new one.
+  #
+  # @see #handle_response_for_request
+  # @see #init
+  def update_challenge_number
+    handle_response_for_request :challenge
+  end
+
+  # Sends a A2S_INFO request to the server and measures the time needed for the
+  # reply
+  #
+  # If this information is vital to you, be sure to call this method regularly
+  # to stay up-to-date.
+  #
+  # @return [Fixnum] The latency of this server in milliseconds
+  # @see #ping
+  def update_ping
+    send_request A2S_INFO_Packet.new
+    start_time = Time.now
+    reply
+    end_time = Time.now
+    @ping = (end_time - start_time) * 1000
+  end
+
+  # Returns a human-readable text representation of the server
+  #
+  # @return [String] Available information about the server in a human-readable
+  #         format
+  def to_s
+    return_string = ''
+
+    return_string << "Ping: #@ping\n"
+    return_string << "Challenge number: #@challenge_number\n"
+
+    unless @info_hash.nil?
+      return_string << "Info:\n"
+      @info_hash.each do |key, value|
+        return_string << "  #{key}: #{value.inspect}\n"
+      end
+    end
+
+    unless @player_hash.nil?
+      return_string << "Players:\n"
+      @player_hash.each_value do |player|
+        return_string << "  #{player}\n"
+      end
+    end
+
+    unless @rules_hash.nil?
+      return_string << "Rules:\n"
+      @rules_hash.each do |key, value|
+        return_string << "  #{key}: #{value}\n"
+      end
+    end
+
+    return_string
+  end
+
+  protected
+
+  # Receives a response from the server
+  #
+  # @return [SteamPacket] The response packet replied by the server
+  def reply
+    @socket.reply
+  end
+
+  # Sends a request packet to the server
+  #
+  # @param [SteamPacket] packet The request packet to send to the server
+  def send_request(packet)
+    @socket.send packet
+  end
+
+end