minecraft-query 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cb4d3f89b9749589d922d925b8120fb71cc1f4f9
+  data.tar.gz: 7c7effd741c452d11bf5ea0d46c0ee57cb18715f
+SHA512:
+  metadata.gz: a8c7986956e9273a2993eb1114876a96e7c9c6d36f3fa4d9902439a9fa873ce31a3defb51ff73d93bee389888abe3df2605e8eef16a9c22773741898d5f80dfa
+  data.tar.gz: 67e3a69b557a2309b21320cf25399e08f25b414cdee5fab2cbef71a261365b3b85bfa31f5670dba50a2deff2e0e56ab69d1ac8be610abaff2f5b51f0e36404ba

data/lib/RubyMinecraft.rb

@@ -0,0 +1,25 @@
+module minecraft-query
+  require 'socket'
+  require 'timeout'
+  
+  require 'query/query'
+  require 'rcon/rcon'
+  
+  #
+  # Connects to a Minecraft server's RCON or Query port to send commands or fetch data.
+  #
+  # Example:
+  #   >> rcon = RCON::Minecraft.new('localhost', 25575)
+  #   => #<RCON::Minecraft:0x007ff6e29e1228 @host="localhost", @port=25575, @socket=nil, @packet=nil, @authed=false, @return_packets=false>
+  #   >> rcon.auth('password')
+  #   => true
+  #   >> rcon.command('say hi')
+  #   => "\xA7d[Server] hi\n"
+  #
+  #   >> query = Query::simpleQuery('localhost', 25565)
+  #   => {:motd=>"ECS Survival", :gametype=>"SMP", :map=>"world", :numplayers=>"1", :maxplayers=>"20"}
+  #   >> players = query[:numplayers] + '/' + query[:maxplayers]
+  #   => 1/20
+  #
+  
+end

data/lib/query/query.rb

@@ -0,0 +1,90 @@
+class Query
+  def self.init
+    @sock = UDPSocket.new
+    @sock.connect(@addr,@port)
+    @val = {}
+    @buff = nil
+    key
+  end
+  
+  def self.key
+    begin
+      timeout(5) do
+        start = @sock.send("\xFE\xFD\x09\x01\x02\x03\x04".force_encoding(Encoding::ASCII_8BIT), 0)
+        t = @sock.recvfrom(1460)[0]
+        key = t[5...-1].to_i
+        @key = Array(key).pack('N')
+      end
+    rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+      return false
+    end
+  end
+
+
+  def self.simpleQuery(addr = 'localhost', port = 25565)
+    @addr = addr
+    @port = port
+    init
+    begin
+      timeout(2) do
+        query = @sock.send("\xFE\xFD\x00\x01\x02\x03\x04".force_encoding(Encoding::ASCII_8BIT) + @key, 0)
+        data = @sock.recvfrom(1460)[0]
+        buffer = data[5...-1]
+        @val[:motd], @val[:gametype], @val[:map], @val[:numplayers], @val[:maxplayers], @buf = buffer.split("\x00", 6)
+        if @sock != nil
+          @sock.close
+        end
+      end
+      return @val
+    rescue StandardError => e
+      return false, e
+    end
+  end
+  
+  def self.fullQuery(addr = 'localhost', port = 25565)
+    @addr = addr
+    @port = port
+    init
+    begin
+      timeout(2) do
+        query = @sock.send("\xFE\xFD\x00\x01\x02\x03\x04".force_encoding(Encoding::ASCII_8BIT) + @key + "\x01\x02\x03\x04".force_encoding(Encoding::ASCII_8BIT), 0)
+        data = @sock.recvfrom(1460)[0]
+        buffer = data[11...-1]
+        items, players = buffer.split("\x00\x00\x01player_\x00\x00".force_encoding(Encoding::ASCII_8BIT))
+        if items[0...8] == 'hostname'
+          items = 'motd' + items[8...-1]
+        end
+        vals = {}
+        items = items.split("\x00")
+        items.each_with_index do |key, idx|
+          next unless idx % 2 == 0
+          vals[key] = items[idx + 1]
+        end
+
+        vals["motd"] = vals["hostname"]
+        vals.delete("hostname")
+        vals.delete("um") if vals["um"]
+
+        players = players[0..-2] if players
+        
+        if players
+          vals[:players] = players.split("\x00")
+        end
+        puts vals
+        vals["raw_plugins"] = vals["plugins"]
+        parts = vals["raw_plugins"].split(":")
+        server = parts[0].strip() if parts[0]
+        plugins = []
+        if parts.size == 2
+          plugins = parts[1].split(";").map {|value| value.strip() }
+        end
+        vals["plugins"] = plugins
+        vals["server"] = server
+        vals["timestamp"] = Time.now
+        return vals.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+      end
+    rescue StandardError => e
+      return false, e
+    end
+  end
+end

data/lib/rcon/rcon.rb

@@ -0,0 +1,435 @@
+module RCON
+    
+  class Query
+
+    #
+    # Convenience method to scrape input from cvar output and return that data.
+    # Returns integers as a numeric type if possible.
+    #
+    # ex: rcon.cvar("mp_friendlyfire") => 1
+    #
+
+    def cvar(cvar_name)
+      response = command(cvar_name)
+      match = /^.+?\s(?:is|=)\s"([^"]+)".*$/.match response
+      match = match[1]
+      if /\D/.match match
+        return match
+      else
+        return match.to_i
+      end
+    end
+  end
+  
+  class Packet
+  end
+  
+  class Packet::Source
+    # execution command
+    COMMAND_EXEC = 2
+    # auth command
+    COMMAND_AUTH = 3
+    # auth response
+    RESPONSE_AUTH = 2
+    # normal response
+    RESPONSE_NORM = 0
+    # packet trailer
+    TRAILER = "\x00\x00"
+  
+    # size of the packet (10 bytes for header + string1 length)
+    attr_accessor :packet_size
+    # Request Identifier, used in managing multiple requests at once
+    attr_accessor :request_id
+    # Type of command, normally COMMAND_AUTH or COMMAND_EXEC. In response packets, RESPONSE_AUTH or RESPONSE_NORM
+    attr_accessor :command_type
+    # First string, the only used one in the protocol, contains
+    # commands and responses. Null terminated.
+    attr_accessor :string1
+    # Second string, unused by the protocol. Null terminated.
+    attr_accessor :string2
+  
+    #
+    # Generate a command packet to be sent to an already
+    # authenticated RCon connection. Takes the command as an
+    # argument.
+    # 
+    def command(string)
+      @request_id = rand(1000)
+      @string1 = string
+      @string2 = TRAILER
+      @command_type = COMMAND_EXEC
+
+      @packet_size = build_packet.length
+
+      return self
+    end
+  
+    #
+    # Generate an authentication packet to be sent to a newly
+    # started RCon connection. Takes the RCon password as an
+    # argument.
+    #
+    def auth(string)
+      @request_id = rand(1000)
+      @string1 = string
+      @string2 = TRAILER
+      @command_type = COMMAND_AUTH
+    
+      @packet_size = build_packet.length
+    
+      return self
+    end
+  
+    #
+    # Builds a packet ready to deliver, without the size prepended.
+    # Used to calculate the packet size, use #to_s to get the packet
+    # that srcds actually needs.
+    #
+    def build_packet
+      return [@request_id, @command_type, @string1, @string2].pack("VVa#{@string1.length}a2")
+    end
+
+    # Returns a string representation of the packet, useful for
+    # sending and debugging. This include the packet size.
+    def to_s
+      packet = build_packet
+      @packet_size = packet.length
+      return [@packet_size].pack("V") + packet
+    end
+
+  end
+
+  class Source < Query
+    # Packet::Source object that was sent as a result of the last query
+    attr_reader :packet
+    # TCPSocket object
+    attr_reader :socket
+    # Host of connection
+    attr_reader :host
+    # Port of connection
+    attr_reader :port
+    # Authentication Status
+    attr_reader :authed
+    # return full packet, or just data?
+    attr_accessor :return_packets
+  
+    #
+    # Given a host and a port (dotted-quad or hostname OK), creates
+    # a Query::Source object. Note that this will still
+    # require an authentication packet (see the auth() method)
+    # before commands can be sent.
+    #
+
+    def initialize(host = 'localhost', port = 25575)
+      @host = host
+      @port = port
+      @socket = nil
+      @packet = nil
+      @authed = false
+      @return_packets = false
+    end
+  
+    #
+    # See Query#cvar.
+    # 
+  
+    def cvar(cvar_name)
+      return_packets = @return_packets
+      @return_packets = false
+      response = super
+      @return_packets = return_packets
+      return response
+    end
+
+    #
+    # Sends a RCon command to the server. May be used multiple times
+    # after an authentication is successful. 
+    #
+  
+    def command(command)
+    
+      if ! @authed
+        raise NetworkException.new("You must authenticate the connection successfully before sending commands.")
+      end
+
+      @packet = Packet::Source.new
+      @packet.command(command)
+
+      @socket.print @packet.to_s
+      rpacket = build_response_packet
+
+      if rpacket.command_type != Packet::Source::RESPONSE_NORM
+        raise NetworkException.new("error sending command: #{rpacket.command_type}")
+      end
+
+      if @return_packets
+        return rpacket
+      else
+        return rpacket.string1
+      end
+    end
+  
+    #
+    # Requests authentication from the RCon server, given a
+    # password. Is only expected to be used once.
+    #
+  
+    def auth(password)
+      establish_connection
+
+      @packet = Packet::Source.new
+      @packet.auth(password)
+
+      @socket.print @packet.to_s
+      # on auth, one junk packet is sent
+      rpacket = nil
+      2.times { rpacket = build_response_packet }
+
+      if rpacket.command_type != Packet::Source::RESPONSE_AUTH
+        raise NetworkException.new("error authenticating: #{rpacket.command_type}")
+      end
+
+      @authed = true
+      if @return_packets
+        return rpacket
+      else
+        return true
+      end
+    end
+
+    alias_method :authenticate, :auth
+  
+    #
+    # Disconnects from the Source server.
+    #
+  
+    def disconnect
+      if @socket
+        @socket.close
+        @socket = nil
+        @authed = false
+      end
+    end
+  
+    protected
+  
+    #
+    # Builds a Packet::Source packet based on the response
+    # given by the server. 
+    #
+    def build_response_packet
+      rpacket = Packet::Source.new
+      total_size = 0
+      request_id = 0
+      type = 0
+      response = ""
+      message = ""
+    
+
+      loop do
+        break unless IO.select([@socket], nil, nil, 10)
+
+        #
+        # TODO: clean this up - read everything and then unpack.
+        #
+
+        tmp = @socket.recv(14)
+        if tmp.nil?
+          return nil
+        end
+        size, request_id, type, message = tmp.unpack("VVVa*")
+        total_size += size
+      
+        # special case for authentication
+        break if message.sub! /\x00\x00$/, ""
+
+        response << message
+
+        # the 'size - 10' here accounts for the fact that we've snarfed 14 bytes,
+        # the size (which is 4 bytes) is not counted, yet represents the rest
+        # of the packet (which we have already taken 10 bytes from)
+
+        tmp = @socket.recv(size - 10)
+        response << tmp
+        response.sub! /\x00\x00$/, ""
+      end
+    
+      rpacket.packet_size = total_size
+      rpacket.request_id = request_id
+      rpacket.command_type = type
+    
+      # strip nulls (this is actually the end of string1 and string2)
+      rpacket.string1 = response.sub /\x00\x00$/, ""
+      return rpacket
+    end
+  
+    # establishes a connection to the server.
+    def establish_connection
+      if @socket.nil?
+        @socket = TCPSocket.new(@host, @port)
+      end
+    end
+  
+  end
+
+  class Minecraft < Query
+    # Packet::Source object that was sent as a result of the last query
+    attr_reader :packet
+    # TCPSocket object
+    attr_reader :socket
+    # Host of connection
+    attr_reader :host
+    # Port of connection
+    attr_reader :port
+    # Authentication Status
+    attr_reader :authed
+    # return full packet, or just data?
+    attr_accessor :return_packets
+  
+    #
+    # Given a host and a port (dotted-quad or hostname OK), creates
+    # a Query::Minecraft object. Note that this will still
+    # require an authentication packet (see the auth() method)
+    # before commands can be sent.
+    #
+
+    def initialize(host = 'localhost', port = 25575)
+      @host = host
+      @port = port
+      @socket = nil
+      @packet = nil
+      @authed = false
+      @return_packets = false
+   end
+  
+    #
+    # See Query#cvar.
+    # 
+  
+    def cvar(cvar_name)
+      return_packets = @return_packets
+      @return_packets = false
+      response = super
+      @return_packets = return_packets
+      return response
+    end
+
+    #
+    # Sends a RCon command to the server. May be used multiple times
+    # after an authentication is successful. 
+    #
+  
+    def command(command)
+    
+      if ! @authed
+        raise NetworkException.new("You must authenticate the connection successfully before sending commands.")
+      end
+    
+      @packet = Packet::Source.new
+      @packet.command(command)
+
+      @socket.print @packet.to_s
+      rpacket = build_response_packet
+
+      if rpacket.command_type != Packet::Source::RESPONSE_NORM
+        raise NetworkException.new("error sending command: #{rpacket.command_type}")
+      end
+
+      if @return_packets
+        return rpacket
+      else
+        return rpacket.string1
+      end
+    end
+  
+    #
+    # Requests authentication from the RCon server, given a
+    # password. Is only expected to be used once.
+    #
+
+  
+    def auth(password)
+      establish_connection
+    
+      @packet = Packet::Source.new
+      @packet.auth(password)
+
+      @socket.print @packet.to_s
+      rpacket = nil
+      rpacket = build_response_packet
+
+      if rpacket.command_type != Packet::Source::RESPONSE_AUTH
+        raise NetworkException.new("error authenticating: #{rpacket.command_type}")
+      end
+
+      @authed = true
+      if @return_packets
+        return rpacket
+      else
+        return true
+      end
+    end
+
+    alias_method :authenticate, :auth
+  
+    #
+    # Disconnects from the Minecraft server.
+    #
+  
+    def disconnect
+      if @socket
+        @socket.close
+        @socket = nil
+        @authed = false
+      end
+    end
+  
+    protected
+  
+    #
+    # Builds a Packet::Source packet based on the response
+    # given by the server. 
+    #
+    def build_response_packet
+      rpacket = Packet::Source.new
+      total_size = 0
+      request_id = 0
+      type = 0
+      response = ""
+      message = ""
+      message2 = ""
+
+      tmp = @socket.recv(4)
+      if tmp.nil?
+        return nil
+      end
+      size = tmp.unpack("V1")
+      tmp = @socket.recv(size[0])
+      request_id, type, message, message2 = tmp.unpack("V1V1a*a*")
+      total_size = size[0]
+    
+      rpacket.packet_size = total_size
+      rpacket.request_id = request_id
+      rpacket.command_type = type
+    
+      # strip nulls (this is actually the end of string1 and string2)
+      message.sub! /\x00\x00$/, ""
+      message2.sub! /\x00\x00$/, ""
+      rpacket.string1 = message
+      rpacket.string2 = message2
+      return rpacket
+    end
+  
+    # establishes a connection to the server.
+    def establish_connection
+      if @socket.nil?
+        @socket = TCPSocket.new(@host, @port)
+      end
+    end
+  
+  end
+
+  class NetworkException < Exception
+  end
+
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: minecraft-query
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tyler Doherty
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-13 00:00:00.000000000 Z
+dependencies: []
+description: A gem to retrieve data from a Minecraft server's query interface and
+  manage a Minecraft or SRCDS server via RCON.
+email: tyler@leonplay.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/RubyMinecraft.rb
+- lib/query/query.rb
+- lib/rcon/rcon.rb
+homepage: http://github.com/Tylerjd/RubyMinecraft
+licenses:
+- New BSD License
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Minecraft Querying lib
+test_files: []