steam-condenser 1.2.0 → 1.2.1

data/pkg/steam-condenser-1.2.0/lib/steam/servers/master_server.rb

@@ -0,0 +1,182 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2008-2011, Sebastian Staudt
+
+require 'errors/timeout_error'
+require 'steam/packets/a2m_get_servers_batch2_packet'
+require 'steam/packets/c2m_checkmd5_packet'
+require 'steam/packets/s2m_heartbeat2_packet'
+require 'steam/servers/server'
+require 'steam/sockets/master_server_socket'
+
+# This class represents a Steam master server and can be used to get game
+# servers which are publicly available
+#
+# An intance of this class can be used much like Steam's server browser to get
+# a list of available game servers, including filters to narrow down the search
+# results.
+#
+# @author Sebastian Staudt
+class MasterServer
+
+  include Server
+
+  # The default number of allowed retries
+  @@retries = 3
+
+  # The master server address to query for GoldSrc game servers
+  GOLDSRC_MASTER_SERVER = 'hl1master.steampowered.com', 27010
+
+  # The master server address to query for Source game servers
+  SOURCE_MASTER_SERVER = 'hl2master.steampowered.com', 27011
+
+  # The region code for the US east coast
+  REGION_US_EAST_COAST = 0x00
+
+  # The region code for the US west coast
+  REGION_US_WEST_COAST = 0x01
+
+  # The region code for South America
+  REGION_SOUTH_AMERICA = 0x02
+
+  # The region code for Europe
+  REGION_EUROPE = 0x03
+
+  # The region code for Asia
+  REGION_ASIA = 0x04
+
+  # The region code for Australia
+  REGION_AUSTRALIA = 0x05
+
+  # The region code for the Middle East
+  REGION_MIDDLE_EAST = 0x06
+
+  # The region code for Africa
+  REGION_AFRICA = 0x07
+
+  # The region code for the whole world
+  REGION_ALL = 0xFF
+
+  # Sets the number of consecutive requests that may fail, before getting
+  # the server list is cancelled (default: 3)
+  #
+  # @param [Fixnum] The number of allowed retries
+  def self.retries=(retries)
+    @@retries = retries
+  end
+
+  # Request a challenge number from the master server.
+  #
+  # This is used for further communication with the master server.
+  #
+  # @note Please note that this is **not** needed for finding servers using
+  #       {#servers}.
+  # @return [Fixnum] The challenge number from the master server
+  # @see #send_heartbeat
+  def challenge
+    failsafe do
+      @socket.send C2M_CHECKMD5_Packet.new
+      @socket.reply.challenge
+    end
+  end
+
+  # Initializes the socket to communicate with the master server
+  #
+  # @see MasterServerSocket
+  def init_socket
+    @socket = MasterServerSocket.new @ip_address, @port
+  end
+
+  # Returns a list of game server matching the given region and filters
+  #
+  # Filtering:
+  # Instead of filtering the results sent by the master server locally, you
+  # should at least use the following filters to narrow down the results sent
+  # by the master server.
+  #
+  # Available filters:
+  #
+  # * `\type\d`: Request only dedicated servers
+  # * `\secure\1`: Request only secure servers
+  # * `\gamedir\[mod]`: Request only servers of a specific mod
+  # * `\map\[mapname]`: Request only servers running a specific map
+  # * `\linux\1`: Request only linux servers
+  # * `\emtpy\1`: Request only **non**-empty servers
+  # * `\full\1`: Request only servers **not** full
+  # * `\proxy\1`: Request only spectator proxy servers
+  #
+  # @note Receiving all servers from the master server is taking quite some
+  #       time.
+  # @param [Fixnum] region_code The region code to specify a location of the
+  #        game servers
+  # @param [String] filters The filters that game servers should match
+  # @param [Boolean] force Return a list of servers even if an error occured
+  #        while fetching them from the master server
+  # @raise [SteamCondenser::TimeoutError] if too many timeouts occur while
+  #        querying the master server
+  # @return [Array<Array<String>>] A list of game servers matching the given
+  #         region and filters
+  # @see A2M_GET_SERVERS_BATCH2_Packet
+  # @see MasterServer.retries=
+  def servers(region_code = MasterServer::REGION_ALL, filters = '', force = false)
+    fail_count     = 0
+    finished       = false
+    current_server = '0.0.0.0:0'
+    server_array   = []
+
+    begin
+      failsafe do
+        begin
+          @socket.send A2M_GET_SERVERS_BATCH2_Packet.new(region_code, current_server, filters)
+          begin
+            servers = @socket.reply.servers
+            servers.each do |server|
+              if server == '0.0.0.0:0'
+                finished = true
+              else
+                current_server = server
+                server_array << server.split(':')
+              end
+            end
+            fail_count = 0
+          rescue SteamCondenser::TimeoutError
+            raise $! if (fail_count += 1) == @@retries
+          end
+        end while !finished
+      end
+    rescue SteamCondenser::TimeoutError
+      raise $! unless force
+    end
+
+    server_array
+  end
+
+  # Sends a constructed heartbeat to the master server
+  #
+  # This can be used to check server versions externally.
+  #
+  # @param [Hash<Symbol, Object>] The data to send with the heartbeat request
+  # @raise [SteamCondenserError] if heartbeat data is missing the
+  #        challenge number or the reply cannot be parsed
+  # @return [Array<SteamPacket>] Zero or more reply packets from the server.
+  #         Zero means either the heartbeat was accepted by the master or there
+  #         was a timeout. So usually it's best to repeat a heartbeat a few
+  #         times when not receiving any packets.
+  # @see S2M_HEARTBEAT2_Packet
+  def send_heartbeat(data)
+    reply_packets = []
+
+    failsafe do
+      @socket.send S2M_HEARTBEAT2_Packet.new(data)
+
+      begin
+        loop { reply_packets << @socket.reply }
+      rescue SteamCondenser::TimeoutError
+      end
+    end
+
+    reply_packets
+  end
+
+end

data/pkg/steam-condenser-1.2.0/lib/steam/servers/server.rb

@@ -0,0 +1,104 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2011, Sebastian Staudt
+
+require 'socket'
+
+# This module is included by all classes implementing server functionality
+#
+# It provides basic name resolution features and the ability to rotate between
+# different IP addresses belonging to a single DNS name.
+#
+# @author Sebastian Staudt
+module Server
+
+  # Returns a list of host names associated with this server
+  #
+  # @return [Array<String>] The host names of this server
+  attr_reader :host_names
+
+  # Returns a list of IP addresses associated with this server
+  #
+  # @return [Array<String>] The IP addresses of this server
+  attr_reader :ip_addresses
+
+  # Creates a new server instance with the given address and port
+  #
+  # @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
+  # @see init_socket
+  # @raise [SteamCondenserError] if an host name cannot be resolved
+  def initialize(address, port = nil)
+    address = address.to_s
+    address, port = address.split(':', 2) if address.include? ':'
+
+    @host_names   = []
+    @ip_addresses = []
+    @ip_index     = 0
+    @port         = port
+
+    Socket.getaddrinfo(address, port, Socket::AF_INET, Socket::SOCK_DGRAM).
+           each do |address|
+      @host_names << address[2]
+      @ip_addresses << address[3]
+    end
+
+    @ip_address = @ip_addresses.first
+
+    init_socket
+  end
+
+  # Rotate this server's IP address to the next one in the IP list
+  #
+  # If this method returns `true`, it indicates that all IP addresses have been
+  # used, hinting at the server(s) being unreachable. An appropriate action
+  # should be taken to inform the user.
+  #
+  # Servers with only one IP address will always cause this method to return
+  # `true` and the sockets will not be reinitialized.
+  #
+  # @return [Boolean] `true`, if the IP list reached its end. If the list
+  #         contains only one IP address, this method will instantly return
+  #         `true`
+  # @see #init_socket
+  def rotate_ip
+    return true if @ip_addresses.size == 1
+
+    @ip_index = (@ip_index + 1) % @ip_addresses.size
+    @ip_address = @ip_addresses[@ip_index]
+
+    init_socket
+
+    @ip_index == 0
+  end
+
+  protected
+
+  # Execute an action in the context of this server's current IP address
+  #
+  # Any failure will cause the IP to rotate to the next IP in the server's IP
+  # list and the execution will be repeated for the next IP address. If the IP
+  # rotation reaches the end of the list, the error will be reraised.
+  #
+  # @param [Proc] proc The action to be executed in a failsafe way
+  # @see #rotate_ip
+  def failsafe(&proc)
+    begin
+      proc.call
+    rescue
+      raise $! if rotate_ip
+      failsafe &proc
+    end
+  end
+
+  # Initializes the socket(s) to communicate with the server
+  #
+  # @abstract Must be implemented in including classes to prepare sockets for
+  #           server communication
+  def init_socket
+  end
+
+end

data/pkg/steam-condenser-1.2.0/lib/steam/servers/source_server.rb

@@ -0,0 +1,98 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2008-2011, Sebastian Staudt
+
+require 'errors/rcon_no_auth_error'
+require 'steam/packets/rcon/rcon_auth_request'
+require 'steam/packets/rcon/rcon_auth_response'
+require 'steam/packets/rcon/rcon_exec_request'
+require 'steam/packets/rcon/rcon_terminator'
+require 'steam/servers/game_server'
+require 'steam/servers/master_server'
+require 'steam/sockets/rcon_socket'
+require 'steam/sockets/source_socket'
+
+# This class represents a Source game server and can be used to query
+# information about and remotely execute commands via RCON on the server
+#
+# A Source game server is an instance of the Source Dedicated Server (SrcDS)
+# running games using Valve's Source engine, like Counter-Strike: Source,
+# Team Fortress 2 or Left4Dead.
+#
+# @author Sebastian Staudt
+# @see GoldSrcServer
+class SourceServer
+
+  include GameServer
+
+  # Returns a master server instance for the default master server for Source
+  # games
+  #
+  # @return [MasterServer] The Source master server
+  def self.master
+    MasterServer.new *MasterServer::SOURCE_MASTER_SERVER
+  end
+
+  # Creates a new instance of a server object representing a Source server,
+  # i.e. SrcDS instance
+  #
+  # @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
+  end
+
+  # Initializes the sockets to communicate with the Source server
+  #
+  # @see RCONSocket
+  # @see SourceSocket
+  def init_socket
+    @rcon_socket = RCONSocket.new @ip_address, @port
+    @socket      = SourceSocket.new @ip_address, @port
+  end
+
+  # Authenticates the connection for RCON communication with the server
+  #
+  # @param [String] password The RCON password of the server
+  # @return [Boolean] whether authentication was successful
+  # @see #rcon_authenticated?
+  # @see #rcon_exec
+  def rcon_auth(password)
+    @rcon_request_id = rand 2**16
+
+    @rcon_socket.send RCONAuthRequest.new(@rcon_request_id, password)
+    @rcon_socket.reply
+    reply = @rcon_socket.reply
+
+    @rcon_authenticated = reply.request_id == @rcon_request_id
+  end
+
+  # Remotely executes a command on the server via RCON
+  #
+  # @param [String] command The command to execute on the server via RCON
+  # @return [String] The output of the executed command
+  # @see #rcon_auth
+  def rcon_exec(command)
+    raise RCONNoAuthError unless @rcon_authenticated
+
+    @rcon_socket.send RCONExecRequest.new(@rcon_request_id, command)
+    @rcon_socket.send RCONTerminator.new(@rcon_request_id)
+
+    response = []
+    begin
+      response_packet = @rcon_socket.reply
+      if response_packet.is_a? RCONAuthResponse
+        @rcon_authenticated = false
+        raise RCONNoAuthError
+      end
+      response << response_packet.response
+    end while response.size < 3 || response_packet.response.size > 0
+
+    response.join('').strip
+  end
+
+end

data/pkg/steam-condenser-1.2.0/lib/steam/sockets/goldsrc_socket.rb

@@ -0,0 +1,142 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2008-2011, Sebastian Staudt
+
+require 'core_ext/stringio'
+require 'errors/rcon_ban_error'
+require 'errors/rcon_no_auth_error'
+require 'errors/timeout_error'
+require 'steam/packets/steam_packet_factory'
+require 'steam/packets/rcon/rcon_goldsrc_request'
+require 'steam/sockets/steam_socket'
+
+# This class represents a socket used to communicate with game servers based on
+# the GoldSrc engine (e.g. Half-Life, Counter-Strike)
+#
+# @author Sebastian Staudt
+class GoldSrcSocket
+
+  include SteamSocket
+
+  # Creates a new socket to communicate with the server on the given IP address
+  # and port
+  #
+  # @param [String] ipaddress Either the IP address or the DNS name of the
+  #        server
+  # @param [Fixnum] port_number The port the server is listening on
+  # @param [Boolean] is_hltv `true` if the target server is a HTLV instance.
+  #        HLTV behaves slightly different for RCON commands, this flag
+  #        increases compatibility.
+  def initialize(ipaddress, port_number = 27015, is_hltv = false)
+    super ipaddress, port_number
+
+    @is_hltv = is_hltv
+  end
+
+  # Reads a packet from the socket
+  #
+  # The Source query protocol specifies a maximum packet size of 1,400 bytes.
+  # Bigger packets will be split over several UDP packets. This method
+  # reassembles split packets into single packet objects.
+  #
+  # @return [SteamPacket] The packet replied from the server
+  def reply
+    receive_packet 1400
+
+    if @buffer.long == 0xFFFFFFFE
+      split_packets = []
+      begin
+        request_id = @buffer.long
+        packet_number_and_count = @buffer.byte
+        packet_count = packet_number_and_count & 0xF
+        packet_number = (packet_number_and_count >> 4) + 1
+
+        split_packets[packet_number - 1] = @buffer.get
+
+        puts "Received packet #{packet_number} of #{packet_count} for request ##{request_id}" if $DEBUG
+
+        if split_packets.size < packet_count
+          begin
+            bytes_read = receive_packet
+          rescue SteamCondenser::TimeoutError
+            bytes_read = 0
+          end
+        else
+          bytes_read = 0
+        end
+      end while bytes_read > 0 && @buffer.long == 0xFFFFFFFE
+
+      packet = SteamPacketFactory.reassemble_packet(split_packets)
+    else
+      packet = SteamPacketFactory.packet_from_data(@buffer.get)
+    end
+
+    puts "Got reply of type \"#{packet.class.to_s}\"." if $DEBUG
+
+    packet
+  end
+
+  # Executes the given command on the server via RCON
+  #
+  # @param [String] password The password to authenticate with the server
+  # @param [String] command The command to execute on the server
+  # @raise [RCONBanError] if the IP of the local machine has been banned on the
+  #        game server
+  # @raise [RCONNoAuthError] if the password is incorrect
+  # @return [RCONGoldSrcResponse] The response replied by the server
+  # @see #rcon_challenge
+  # @see #rcon_send
+  def rcon_exec(password, command)
+    rcon_challenge if @rcon_challenge.nil? || @is_hltv
+
+    rcon_send "rcon #@rcon_challenge #{password} #{command}"
+    rcon_send "rcon #@rcon_challenge #{password}"
+    if @is_hltv
+      begin
+        response = reply.response
+      rescue SteamCondenser::TimeoutError
+        response = ''
+      end
+    else
+      response = reply.response
+    end
+
+    if response.strip == 'Bad rcon_password.'
+      raise RCONNoAuthError
+    elsif response.strip == 'You have been banned from this server.'
+      raise RCONBanError
+    end
+
+    begin
+      response_part = reply.response
+      response << response_part
+    end while response_part.size > 0
+
+    response
+  end
+
+  # Requests a challenge number from the server to be used for further requests
+  #
+  # @raise [RCONBanError] if the IP of the local machine has been banned on the
+  #        game server
+  # @see #rcon_send
+  def rcon_challenge
+    rcon_send 'challenge rcon'
+    response = reply.response.strip
+
+    if response.strip == 'You have been banned from this server.'
+      raise RCONBanError
+    end
+
+    @rcon_challenge = response[14..-1]
+  end
+
+  # Wraps the given command in a RCON request packet and send it to the server
+  #
+  # @param [String] command The RCON command to send to the server
+  def rcon_send(command)
+    send RCONGoldSrcRequest.new(command)
+  end
+
+end