steamrb 0.1.0

data/lib/steam/logger.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'logger'
+
+module Steam
+  # Small wrapper around the Ruby Logger class
+  class Logger < ::Logger
+    # Log level WARN
+    WARN  = ::Logger::WARN
+    # Log level INFO
+    INFO  = ::Logger::INFO
+    # Log level ERROR
+    ERROR = ::Logger::ERROR
+    # Log level DEBUG
+    DEBUG = ::Logger::DEBUG
+    # Log level FATAL
+    FATAL = ::Logger::FATAL
+
+    # Create a Logger that logs to a given IO object
+    #
+    # @param io [#read] The io object
+    # @param level [Integer] log lvel
+    def initialize(io, level = DEBUG)
+      self.level = level
+      super(io)
+    end
+  end
+end

data/lib/steam/networking/connection.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+require 'socket'
+require 'ostruct'
+
+module Steam
+  module Networking
+    # Represents a connection to Steam. Holds the session key, yields
+    # packets to the caller
+    #
+    # @example Creating a Connection
+    #   connection = Connection.new(Server.new(ip, port))
+    #   connection.each_packet do |packet|
+    #   end
+    #
+    # @see Packet
+    class Connection
+      # The internal list of Packet objects read from the TCP socket
+      attr_reader :packets
+
+      def initialize(server, socket = nil)
+        @session_key = nil
+        @packets = PacketList.new
+        @socket = socket
+        @mutex = Mutex.new
+        @server = server
+        self
+      end
+
+      # Opens the underlying socket
+      def open
+        self.session_key = nil
+        self.disconnecting = false
+        self.socket = TCPSocket.open(@server.host, @server.port)
+      end
+
+      # Closes the socket
+      def disconnect
+        self.session_key = nil
+        self.disconnecting = true
+        socket.close
+      end
+
+      # Determine if the connection is disconnected. This is determined
+      # by the socket being opened or close.
+      #
+      # @return [Bool]
+      def disconnected?
+        socket.closed?
+      end
+
+      # Sets the connections session key. Used for crypto
+      def session_key=(v)
+        @mutex.synchronize { @session_key = v }
+      end
+
+      # Send a Message to the Steam server. If we are in an encrypted
+      # session the Packet body is encrypted before it is sent.
+      #
+      # @see Protocol::Message
+      # @see Networking::Packet
+      #
+      # @param msg [Networking::Message] the message to send
+      def send_msg(msg)
+        data = msg.encode
+        data = Crypto.encrypt(data, session_key) if session_key
+
+        packet = Packet.new(data)
+        write_socket(packet.encode)
+      end
+
+      # Yields each Packet from the socket to the calling block.
+      #
+      # Starts a thread for reading from the socket into a queue. And another
+      # thread to consume that queue. Packets that are consumed from the queue
+      # will be yielded to the block
+      #
+      # @see Networking::Packet
+      def each_packet(&block)
+        start_read_thread
+        start_listen_thread(&block)
+      end
+
+      private
+
+      # @api private
+      def start_listen_thread
+        @listen_thread = Thread.new do
+          until disconnected?
+            packet = @packets.pop
+            yield packet if packet
+          end
+        end
+        @listen_thread.abort_on_exception = true
+      end
+
+      # @api private
+      def start_read_thread
+        @read_thread = Thread.new do
+          until disconnected?
+            packet = recv_packet_from_socet
+            @packets.add(packet) if packet
+          end
+        end
+        @read_thread.abort_on_exception = true
+      end
+
+      # @api private
+      def recv_packet_from_socet
+        packet_size = read_packet_header
+        read_packet(packet_size) if packet_size
+      end
+
+      # @api private
+      def read_packet_header
+        data = read_socket(8)
+        return nil if data.nil?
+
+        header = ByteReader.new(StringIO.new(data))
+
+        size  = header.signed_int32
+        magic = header.string(4)
+        raise "invalid packet: size=#{size}, magic=#{magic}" unless
+                  size.nonzero? && magic == Packet::TCP_MAGIC
+        size
+      end
+
+      # @api private
+      def read_packet(packet_size)
+        data = read_socket(packet_size)
+        data = Crypto.decrypt(data, session_key) if session_key
+        Packet.new(data)
+      end
+
+      # @api private
+      def write_socket(data)
+        socket.write(data)
+      rescue IOError => e
+        # If we are disconnecting, the socket is allowed to be closed
+        return 0 if disconnecting
+        raise e
+      end
+
+      # @api private
+      def read_socket(len)
+        socket.read(len)
+      rescue IOError => e
+        # If we are disconnecting, the socket is allowed to be closed
+        return nil if disconnecting
+        raise e
+      end
+
+      # @api private
+      def socket
+        @mutex.synchronize { @socket }
+      end
+
+      # @api private
+      def socket=(socket)
+        @mutex.synchronize { @socket = socket }
+      end
+
+      # @api private
+      def disconnecting
+        @mutex.synchronize { @disconnecting }
+      end
+
+      # @api private
+      def disconnecting=(v)
+        @mutex.synchronize { @disconnecting = v }
+      end
+
+      # @api private
+      def session_key
+        @mutex.synchronize { @session_key }
+      end
+    end
+  end
+end

data/lib/steam/networking/packet.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+module Steam
+  module Networking
+    # An object representing a packet from the connection.
+    #
+    # The packets come in the form
+    #
+    # LENGTH MAGIC BODY
+    #
+    # To create a packet only the body needs to be supplied. The body should
+    # never contain the MAGIC or LENGTH
+    class Packet
+      # Valve's TCP Packet identifier
+      TCP_MAGIC = 'VT01'
+
+      # The raw bytes of the TCP packet
+      attr_reader :body
+
+      # The EMsg type derived from the Packet body
+      attr_reader :msg_type
+      alias emsg msg_type
+
+      # Instantiates a Packet object
+      #
+      # @param body [String]
+      def initialize(body)
+        raise 'packet must have raw tcp body' if body.nil? || body.empty?
+
+        @body     = body
+        @io       = ByteReader.new(StringIO.new(body))
+        @iden     = ByteReader.new(StringIO.new(body)).unsigned_int32
+        @msg_type = @iden & ~Message::PROTO_MASK
+        self
+      end
+
+      # Encode a Packet to a byte string
+      #
+      # @return [String] byte string representation of the Packet
+      def encode
+        stream = ByteWriter.new
+        stream.write_unsigned_int32(body.length)
+        stream.write_string(TCP_MAGIC)
+        stream.write_string(body)
+        stream.string
+      end
+
+      # Returns true if the Packet contains other packets
+      #
+      # @return [Bool]
+      def multi?
+        @msg_type == EMsg::MULTI
+      end
+
+      # Returns true if the Packet is Protobuf backed
+      #
+      # @return [Bool]
+      def proto?
+        (@iden & Message::PROTO_MASK) == Message::PROTO_MASK
+      end
+
+      # Converts the Packet into a Message object.
+      #
+      # @param msg [Message] The message to decode from the packet
+      # @return [Message] the resulting message
+      def as_message(msg)
+        cm = if proto?
+               ProtobufMessage.new(MsgHdrProtoBuf.new, msg, @msg_type)
+             else
+               ClientMessage.new(MsgHdr.new, msg, @msg_type)
+             end
+
+        cm.decode(@io)
+        cm
+      end
+    end
+  end
+end

data/lib/steam/networking/packet_list.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Steam
+  module Networking
+    # Holds a list of Packet objects in a non-blocking thread safe queue
+    class PacketList
+      def initialize
+        @packets = Thread::Queue.new
+      end
+
+      # Adds a Packet to the internal queue
+      #
+      # @param packet [Packet] the Packet to add
+      def add(packet)
+        @packets.push(packet)
+      end
+
+      # Removes the next message
+      #
+      # @return [Packet] The Packet object
+      def pop
+        @packets.pop(true)
+      rescue ThreadError
+        nil
+      end
+    end
+  end
+end

data/lib/steam/networking.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Steam
+  # Namespace for any Networking concerns.
+  #
+  # @see Networking::Connection
+  # @see Networking::Packet
+  # @see Networking::PacketList
+  module Networking
+  end
+end
+
+require 'steam/networking/packet_list'
+require 'steam/networking/connection'
+require 'steam/networking/packet'

data/lib/steam/plugins.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+module Steam
+  # Allows "plugins" via gems. The plugins are just gems that react to client
+  # events an maybe expose an additional api. For example a CSGO plugin would
+  # be respoinsible for strictly CSGO related things and could have syntatic
+  # candy for things such as logging the player on, and handling the connection
+  # flow of CSGO related connection events. It could also provide the abililty
+  # to send specific GC messages like the requesting of match info.
+  #
+  # The plugins are refered to by name, ie: csgo
+  #
+  # The CSGO plugin would be a gem that is named `steam-csgo` and has the
+  # following struture.
+  #
+  #  -steam-csgo
+  #    - lib
+  #      - steam
+  #        - csgo
+  #          - base.rb
+  #        - csgo.rb
+  #    - ... other gem things ...
+  #
+  # The fastpeek/steam-csgo gem is a CSGO plugin for references
+  class Plugins
+    include Enumerable
+
+    attr_reader :client, :loaded_plugins
+
+    # Instantiate a new Plugins engine
+    def initialize(client)
+      @client = client
+      @mutex = Mutex.new
+      @plugins = []
+      @loaded_plugins = []
+      @loaded = false
+    end
+
+    # Determine if the Client has a plugin loaded
+    #
+    # @param plugin [Symbol]
+    # @return [Bool]
+    def loaded?(plugin)
+      @loaded_plugins.include?(plugin.to_sym)
+    end
+
+    # Add a plugin to the internal list. Plugins are not loaded until
+    # #load is called.
+    def plugin(plugin)
+      @plugins << plugin.to_sym
+      @plugins
+    end
+
+    # Load the plugins. Attempt to require each plugin. If the require call
+    # fails an error message is printed.
+    #
+    # If the client has already loaded the plugins, they are not loaded again.
+    #
+    # @return [Integer] the number of plugins it loaded
+    def load
+      return true if @loaded
+      @loaded_plugins = require_plugins
+      Steam.logger.debug("Loaded plugins: #{loaded_plugins}")
+      setup_plugin_helpers(loaded_plugins)
+      @loaded = true
+      @loaded_plugins.count >= 1
+    end
+
+    private
+
+    # @api private
+    def setup_plugin_helpers(loaded_plugins)
+      loaded_plugins.each { |plugin| define_plugin_ivar(plugin) }
+    end
+
+    # @api private
+    def define_plugin_ivar(plugin)
+      client.class.class_eval do
+        define_method plugin do
+          var = instance_variable_get("@#{plugin}")
+
+          unless var
+            val = "Steam::#{plugin.capitalize}::Base".constantize.new(self)
+            var = instance_variable_set("@#{plugin}", val)
+          end
+          var
+        end
+      end
+    end
+
+    # @api private
+    def require_plugins
+      required_plugins = @plugins.map do |plugin|
+        begin
+          require "steam/#{plugin}"
+          plugin
+        rescue LoadError
+          msg = "Failed to load #{plugin} plugin. Is it in your Gemfile?"
+          Steamd.logger.error(msg)
+          nil
+        end
+      end
+
+      required_plugins.compact
+    end
+  end
+end

data/lib/steam/protocol/client_message.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Steam
+  module Protocol
+    # Represents a Message received or sent to the Steam
+    # network.
+    #
+    # Client messages typically don't have session or steam meta
+    # data associated with them.
+    class ClientMessage
+      include Message
+    end
+  end
+end

data/lib/steam/protocol/gc_message.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module Steam
+  module Protocol
+    # Represents a Game Coordinator Message. Not protobuf backed
+    class GcMessage
+      include Message
+    end
+  end
+end

data/lib/steam/protocol/gc_protobuf_message.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Steam
+  module Protocol
+    # Represents a GC Message received or sent to the Steam
+    # network via the Game Coordinator.
+    class GcProtobufMessage < ProtobufMessage
+      # Convert the internal gc message into the message we care about
+      #
+      # @param klass [Message] the type of message
+      def as(klass)
+        klass = klass.class unless klass.is_a?(Class)
+        io = StringIO.new(body.payload)
+        @header.decode_from(io)
+        klass.decode(io.read)
+      end
+    end
+  end
+end

data/lib/steam/protocol/message.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+module Steam
+  module Protocol
+    # The base Steam message. Each message contains a header, body and emsg
+    # attribute.
+    #
+    # The #emsg corresponds to the constants EMsg in the SteamLanguage
+    #
+    # @see ClientMessage
+    # @see ProtobufMessage
+    module Message
+      # Valve's mask for determining if a packet is Protobuf backed
+      PROTO_MASK = 0x80000000
+
+      # Each packet has a header. The header is defined by the Steam Language.
+      # A header can be a MsgHdr, or a MsgHdrProtoBuf
+      #
+      # @see MsgHdrProtoBuf
+      # @see MsgHdr
+      attr_reader :header
+
+      # Each packet has a body, this is the Message being held in the packet.
+      # @see Message
+      attr_reader :body
+
+      # Each packet has an optional byte string payload
+      attr_reader :payload
+
+      # The Message type
+      #
+      # @see EMsg
+      attr_reader :emsg
+
+      # Instantiate a Message object
+      #
+      # @param header [MsgHdr, MsgHdrProtoBuf]
+      # @param body
+      # @param emsg
+      def initialize(header, body, emsg)
+        @header = header
+        @body = body
+        @header.msg = emsg
+        @payload = ByteWriter.new
+        @emsg = emsg
+        nil
+      end
+
+      # By default a Message is not Protobuf backed
+      def proto?
+        false
+      end
+
+      # The steam id associated with the message
+      #
+      # @param _sid [String] the Steam id
+      def steam_id=(_sid)
+        raise NotImplementedError
+      end
+
+      # The session id associated with the message
+      #
+      # @param _sid [String] the Session id
+      def session_id=(_sid)
+        raise NotImplementedError
+      end
+
+      # Decode a Packet from an io object
+      #
+      # @param io [#read] The IO stream
+      def decode(io)
+        @header.decode_from(io)
+
+        if @body.respond_to?(:decode_from)
+          # Steam language
+          @body.decode_from(io)
+        else
+          # Proto
+          @body = @body.class.decode(io.read)
+        end
+      end
+
+      # Encode a Packet from to a string
+      #
+      # @see Packet
+      # @return [String] The byte representation of the Packet
+      def encode
+        io = StringIO.new
+        io.set_encoding('BINARY')
+
+        @header.encode_to(io)
+        body = @body.encode
+        io.write(body)
+        io.write(@payload.string)
+
+        io.string
+      end
+    end
+  end
+end

data/lib/steam/protocol/protobuf_message.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+module Steam
+  module Protocol
+    # Represents a Protobuf message. They have a protobuf header, and body.
+    # Their emsg is masked with the PROTO_MASK flag
+    class ProtobufMessage
+      include Message
+
+      # A Protobuf Message contains a steam id and a session id. It also uses
+      # the PROTO_MASK on the EMsg.
+      def initialize(header, body, emsg)
+        super(header, body, emsg | PROTO_MASK)
+      end
+
+      # Returns the masked protobuf emsg
+      def emsg
+        @emsg & ~PROTO_MASK
+      end
+
+      # Get the steam_id associated with this message
+      #
+      # @return [Integer]
+      def steam_id
+        @header.proto.steamid
+      end
+
+      #
+      # Get the steam_id associated with this message
+      #
+      # @return [Integer]
+      def session_id
+        @header.proto.client_sessionid
+      end
+
+      # The steam id associated with the message
+      #
+      # @param sid [String] the Steam id
+      def steam_id=(sid)
+        @header.proto.steamid = sid
+      end
+
+      # The session id associated with the message
+      #
+      # @param sid [String] the Session id
+      def session_id=(sid)
+        @header.proto.client_sessionid = sid
+      end
+
+      def proto?
+        true
+      end
+    end
+  end
+end

data/lib/steam/protocol.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Steam
+  # Encapsulates the Steam protocol
+  module Protocol
+  end
+end
+
+require 'steam/protocol/message'
+require 'steam/protocol/client_message'
+require 'steam/protocol/protobuf_message'
+require 'steam/protocol/gc_message'
+require 'steam/protocol/gc_protobuf_message'
+
+# @todo remove these
+Steam::ClientMessage = Steam::Protocol::ClientMessage
+Steam::ProtobufMessage = Steam::Protocol::ProtobufMessage
+Steam::GcMessage = Steam::Protocol::GcMessage
+Steam::GcProtobufMessage = Steam::Protocol::GcProtobufMessage
+Steam::Message = Steam::Protocol::Message

data/lib/steam/sentry_file.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+module Steam
+  # Represents a Sentry file on disk
+  #
+  # @todo this will overwrite any existing file, namespace
+  #   to username?
+  class SentryFile
+    # Writes the digest to the sentry file
+    #
+    # @example Write the SentryFile
+    #   file = SentryFile.new
+    #   file.write('sha1digest')
+    #
+    # @param digest [String]
+    def write(digest)
+      File.open(path, 'wb') do |file|
+        file.write(digest)
+      end
+    end
+
+    # Read the digest from the sentry file. Returns
+    # nil if the Sentry file does not exist.
+    #
+    # @example Read the SentryFile
+    #   file = SentryFile.new
+    #   file.read # => 'somedigest'
+    #
+    # @return [String,nil]
+    def read
+      return nil unless File.exist?(path)
+
+      File.open(path, 'rb', &:read)
+    end
+
+    private
+
+    # @api private
+    def path
+      File.expand_path('~/.steam-sentry')
+    end
+  end
+end