steamrb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 99caa4cd2e21acd6cf5b3d53ce3079a6ca6a7a15
+  data.tar.gz: 3ccd1cc12a21b735f67d42d511b94a3c6a9079e2
+SHA512:
+  metadata.gz: 2593c4948cd249f4464e3baabd18252ee7ba1b616cf81955cf5dddfa5303e63b65db3f3ff3ecc0ebb9c8472c50689a568aeb4fbba99cdf89e7b85aa2dd7753b8
+  data.tar.gz: 532adb1b7b9e99a5faff2e845d2a6f689b2684b0b88f181d69c77b65378dcac16e2b2704820309045b2a6a4b49e02f6cc9c0e48b1e5aceae41816e41bcac1a9d

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+Gemfile.lock
+doc/
+.yardoc/

data/.rspec

@@ -0,0 +1,2 @@
+--format progress
+--color

data/.rubocop.yml

@@ -0,0 +1,4 @@
+AllCops:
+  TargetRubyVersion: 2.3
+  Exclude:
+    - lib/steam/protocol/language/*.rb

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.13.2

data/Gemfile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,116 @@
+# Steam
+
+Ruby Client for Steam.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'steam'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install steam
+
+## Usage
+
+To use you may subscribe a listener class to the Steam Client object in order
+to react to events it fires.
+
+```ruby
+require 'steam'
+
+class MyClient < Steam::Client
+  def initialize(username, password)
+    super
+    @username = username
+    @password = password
+    @token = nil
+
+    file = SentryFile.new
+    @sha = file.read
+  end
+
+  def ready
+    steam_user.login(@username, @password, @token, @sha)
+  end
+
+  def on_logon(msg)
+    case msg.body.eresult
+    when EResult::OK
+      # logged in
+    when EResult::ACCOUNT_LOGON_DENIED
+      puts 'Input token'
+      @token = STDIN.gets.chomp
+      restart
+      sleep 5
+    else
+      raise "Error: #{msg.body.eresult}"
+    end
+  end
+end
+
+bot = MyClient.new
+bot.start
+```
+
+You may add game specific APIs by including them as a gem. CSGO plugin is provided by `fastpeek/steam-csgo`.
+
+```ruby
+
+class MyClient < Steam::Client
+  def initialize(username, password)
+    super
+    @username = username
+    @password = password
+    @token = nil
+
+    file = SentryFile.new
+    @sha = file.read
+  end
+
+  def ready
+    steam_user.login(@username, @password, @token, @sha)
+  end
+
+  def csgo_match_info(match_info)
+    # do something with match_info
+  end
+
+  def csgo_ready
+    csgo.request_match_info(3_176_070_719_880_560_711,
+                            3_176_076_024_165_171_409,
+                            39_898)
+  end
+
+  def on_logon(msg)
+    case msg.body.eresult
+    when EResult::OK
+      csgo.start
+    when EResult::ACCOUNT_LOGON_DENIED
+      puts 'Input token'
+      @token = STDIN.gets.chomp
+      restart
+    else
+      raise "Error: #{msg.body.eresult}"
+    end
+  end
+end
+
+bot = MyClient.new
+bot.plugin(:csgo)
+bot.start
+```
+
+## License
+
+MIT
+
+## References
+[SteamKit](https://github.com/SteamRE/SteamKit/)

data/Rakefile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new('spec:units') do |task|
+  task.rspec_opts = '--tag ~integration'
+end
+
+RSpec::Core::RakeTask.new('spec:integration') do |task|
+  task.rspec_opts = '--tag integration'
+end
+
+RuboCop::RakeTask.new do |task|
+  task.options = ['lib/']
+end
+
+desc 'Run all specs and linter'
+task 'spec:all' => ['spec:units', 'spec:integration'] do
+end
+
+task default: ['spec:units']

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'steam'
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ext/string.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Core string extensions
+class String
+  # Camelize a string
+  #
+  # @example Camelize a string
+  #   "hello_world".camelize # => HelloWorld
+  def camelize
+    split('_').collect(&:capitalize).join
+  end
+  alias classify camelize
+
+  # Underscore a String. This method will also downcase the string
+  #
+  # @example Underscore a string
+  #   "HelloWorld" # => "hello_world"
+  def underscore
+    gsub(/::/, '/')
+      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .tr('-', '_')
+      .downcase
+  end
+
+  # Look up a constant via a string.
+  #
+  # @example Using constantize
+  #   "Object".constantize # => Object
+  # rubocop:disable LineLength
+  def constantize
+    names = split('::')
+    names.shift if names.empty? || names.first.empty?
+    constant = Object
+    names.each do |name|
+      constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+    end
+    constant
+  end
+
+  alias snakecase underscore
+end

data/lib/steam/byte_reader.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require 'forwardable'
+
+module Steam
+  # Reads bytes from a given IO object.
+  class ByteReader
+    extend Forwardable
+
+    attr_reader :io
+
+    # Create a ByteReader object
+    #
+    # @param io [:read] an io object
+    def initialize(io)
+      @io = io
+    end
+
+    # Reads an unsigned 64 bit integer from the stream
+    #
+    # @return [Integer] The 64 bit integer
+    def read_int64
+      io.read(8).unpack('C*').each_with_index.reduce(0) do |sum, (byte, index)|
+        sum + byte * (256**index)
+      end
+    end
+    alias int64 read_int64
+
+    # Reads an unsigned short from the stream
+    #
+    # @return [Integer] The short
+    def read_short
+      io.read(2).unpack('S*').first
+    end
+    alias short read_short
+
+    # Reads a string of a given length from the stream
+    #
+    # @return [String] The read string
+    def string(len)
+      io.read(len)
+    end
+
+    # Reads a single bytes from the stream
+    #
+    # @return [Integer] The byte
+    def byte
+      io.read(1).ord
+    end
+
+    # Reads an unsigned 32 bit integer from the stream
+    #
+    # @return [Integer] The 32 bit integer
+    def unsigned_int32
+      io.read(4).unpack('<I*').first
+    end
+
+    # Reads an signed 32 bit integer from the stream
+    #
+    # @return [Integer] The 32 bit integer
+    def signed_int32
+      io.read(4).unpack('<i*').first
+    end
+
+    # Reads an signed 16 bit integer from the stream
+    #
+    # @return [Integer] The 16 bit integer
+    def signed_int16
+      io.read(2).unpack('<s*').first
+    end
+
+    def_delegator :@io, :read, :read
+    def_delegator :@io, :readbyte, :readbyte
+    def_delegator :@io, :eof?, :eof?
+    def_delegator :@io, :tell, :tell
+    def_delegator :@io, :lineno, :lineno
+  end
+end

data/lib/steam/byte_writer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+require 'forwardable'
+
+module Steam
+  # Writes bytes to a given io object
+  class ByteWriter
+    extend Forwardable
+
+    attr_reader :io
+
+    # Wrap an Int64 allowing the lo and hi
+    # 32 bits to be extracted
+    class Int64Type
+      # Create an Int64Type instance
+      #
+      # @param value [Integer] the 64 bit int
+      def initialize(value)
+        @value = value
+      end
+
+      # The low 32 bits
+      #
+      # @return [Integer]
+      def lo
+        @value & 0xFFFFFFFF
+      end
+
+      # The high 32 bits
+      #
+      # @return [Integer]
+      def hi
+        (@value >> 32) & 0xFFFFFFFF
+      end
+
+      # An array of the low and high bits
+      #
+      # @return [Integer]
+      def int32s
+        [lo, hi]
+      end
+    end
+
+    def initialize
+      @io = StringIO.new
+      @io.set_encoding('BINARY')
+    end
+
+    # Rewind the stream
+    def rewind
+      @io.rewind
+    end
+
+    # Writes an unsigned 32 bit integer from the stream
+    def write_unsigned_int32(value)
+      @io.write([value].pack('<I'))
+    end
+
+    # Writes an signed long from the stream
+    def write_signed_long(value)
+      @io.write([value].pack('<l_'))
+    end
+
+    # Writes a 32 bit intger to the stream
+    def write_int32(value)
+      @io.write([value].pack('<l'))
+    end
+
+    # Writes a 64 bit intger to the stream
+    def write_int64(value)
+      int64 = Int64Type.new(value)
+
+      int64.int32s.each do |int|
+        write_int32(int)
+      end
+    end
+
+    # Writes a single byte to the stream
+    def write_byte(byte)
+      @io.write([byte].pack('C'))
+    end
+
+    # Writes the given bytes to the stream
+    def write(bytes)
+      @io.write(bytes)
+    end
+    alias write_string write
+
+    # The byte representation of this writer object
+    #
+    # @return [String] byte representation of this writer object
+    def string
+      @io.rewind
+      @io.string
+    end
+  end
+end

data/lib/steam/client.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+module Steam
+  # Represents a Client on the Steam Network. The Client creates a connection
+  # to the Steam networks, and send and receives Message objects to that
+  # connection.
+  #
+  # The Client holds a collection of handlers that react to received packets,
+  # if they care about the packet data.
+  class Client
+    # The internal connection to Steam
+    attr_reader :connection
+
+    # The Handler for Steam user related events (changing name, login, etc)
+    attr_reader :steam_user
+
+    # The Handler for Steam app related events (play tokens, etc)
+    attr_reader :steam_apps
+
+    # The Handler for the game coordinator events (playing game, etc)
+    attr_reader :game_coordinator
+
+    # A list of tokens requires for the game coordinator to launch games
+    attr_reader :connect_tokens
+
+    # The SteamId for the current user, nil if not logged in
+    attr_reader :steam_id
+
+    # The session id for the current user, nilt if not logged in
+    attr_reader :session_id
+
+    # The plugin engine
+    attr_reader :plugins
+
+    def initialize(connection = nil)
+      connection ||= Networking::Connection.new(ServerList.new.to_a.sample)
+      @connect_tokens = []
+      @steam_user = nil
+      @steam_apps = nil
+      @game_coordinator = nil
+      @steam_id = default_steam_id
+      @connection = connection
+      @plugins = Plugins.new(self)
+      init_handlers
+    end
+
+    # Called by SteamUser handler when the logon message is to be handled.
+    # This must be implemented by the subclass
+    def on_logon(_msg)
+      raise NotImplementedError
+    end
+
+    # Called by SteamUser handler when the user is fully logged in. This must
+    # be implemented by the subclass.
+    def ready
+      raise NotImplementedError
+    end
+
+    # Registers a plugin with the Client via the plugin name
+    #
+    # @param plugin [Symbol,String] the plugin name
+    def plugin(plugin)
+      @plugins.plugin(plugin.to_sym)
+    end
+
+    # Stop and start the Client
+    def restart
+      stop
+      start
+    end
+
+    # Disconnect the Client
+    def stop
+      steam_user.logoff if @steam_id && @session_id
+      connection.disconnect
+      @steam_id = default_steam_id
+      @session_id = nil
+    end
+
+    # Create a new Connection object, and start listening and handling
+    # received packets.
+    #
+    # @return nil
+    def start
+      @plugins.load
+
+      connection.open
+      connection.each_packet do |packet|
+        handle_net_msg(packet)
+      end
+    end
+
+    # Sends a Message to the underlying Steam connection. If we have an active
+    # session, the session id and steam id is automatically associated with
+    # the request
+    #
+    # @param msg [Protocol::Message] the Message to send to Steam
+    def send_msg(msg)
+      Steam.logger.debug("Sending #{msg.body.class.name} to Steam")
+
+      if msg.proto?
+        msg.session_id = session_id
+        msg.steam_id = steam_id.to_i
+      end
+
+      connection.send_msg(msg).nonzero?
+    end
+
+    # Creates a new session for the Client
+    #
+    # @param steam_id [String]
+    # @param session_id [String]
+    def create_session(steam_id, session_id)
+      @steam_id = CommunityId.new(steam_id)
+      @session_id = session_id
+    end
+
+    # Update the Client's internal connection token list
+    #
+    # @param tokens [Array<String>] the new list of tokens
+    # @param max [Integer] the amount of tokens to keep
+    def update_connect_tokens(tokens, max)
+      tokens.each { |t| @connect_tokens.insert(0, t) }
+      @connect_tokens = @connect_tokens.take(max)
+    end
+
+    # Sets the Client's connection session key. Used for encrypting
+    # and decrypting packets
+    #
+    # @param key [String] the key
+    def session_key=(key)
+      connection.session_key = key
+    end
+
+    # Starts the background heartbeat thread.
+    #
+    # @param tick [Integer] the time to wait between
+    #   heartbeat messages
+    def start_heartbeat(tick)
+      Thread.new do |t|
+        t.abort_on_exception = true
+        until connection.disconnected?
+          send_msg(heartbeat_message)
+          sleep(tick)
+        end
+      end
+    end
+
+    # Passes each GC message to any plugins.
+    #
+    # @param msg [GcProtobufMessage] The message to handle
+    def gc_message(msg)
+      @plugins.loaded_plugins.each do |plugin|
+        send(plugin).gc_message(msg)
+      end
+    end
+
+    private
+
+    # Instantiates the various handlers, and adds them to the handler
+    # collection
+    def init_handlers
+      @auth = Handler::Auth.new(self)
+      @steam_user = Handler::SteamUser.new(self)
+      @steam_apps = Handler::SteamApps.new(self)
+      @game_coordinator = Handler::GameCoordinator.new(self)
+
+      @handlers = Handler::Collection.new
+      @handlers.add(@auth, @steam_user, @steam_apps, @game_coordinator)
+    end
+
+    # Handles an incoming packet, if the pack is a multi packet (ie: it contains
+    # more than one packet) each packet is extracted and passed back to this
+    # method.
+    #
+    # @param packet [Packet] the packet to handle
+    def handle_net_msg(packet)
+      return handle_multi(packet) if packet.proto? && packet.multi?
+      @handlers.handle(packet)
+    end
+
+    # Handles a packet containing one or more other Packets. Sometimes
+    # the Packet data will be Gziped, this method handles that case as well.
+    #
+    # @note this method does not ensure the packet is a multi packet, the
+    #   calling method should handle this
+    # @param packet [Networking::Packet] the packet to handle
+    def handle_multi(packet)
+      msg = packet.as_message(Steamclient::CMsgMulti.new)
+
+      body = StringIO.new(msg.body.message_body)
+      payload = if msg.body&.size_unzipped&.nonzero?
+                  Zlib::GzipReader.new(body)
+                else
+                  body
+                end
+
+      handle_packets_from_multi_payload(payload)
+    end
+
+    # Extracts one or more packet from a given payload IO object.
+    #
+    # @param payload [#read] The payload io object
+    def handle_packets_from_multi_payload(payload)
+      reader = ByteReader.new(payload)
+
+      until reader.eof?
+        packet_length = reader.unsigned_int32
+        handle_net_msg(Networking::Packet.new(reader.read(packet_length)))
+      end
+    end
+
+    # The heartbeat message that we send once the user is connected
+    #
+    # @return [ProtobufMessage]
+    def heartbeat_message
+      ProtobufMessage.new(MsgHdrProtoBuf.new,
+                          Steamclient::CMsgClientHeartBeat.new,
+                          EMsg::CLIENT_HEART_BEAT)
+    end
+
+    # The default SteamID to be sent with each message before a user
+    # has been authed
+    # @return [Steam2Id]
+    def default_steam_id
+      Steam2Id.new(EUniverse::PUBLIC, 0, 0)
+    end
+  end
+end