minecraft-query-v2 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: daa1446115224aca2cd52edad125f434b9d637ab
+  data.tar.gz: f2fdc5dd429483ea504820643c471d1c08b90201
+SHA512:
+  metadata.gz: b33861b203b4f4d91767587529f18432d26fd89545889b38a84801aa4970a34c53ea400c4cc1ebb2bb6d079649850b3971f8e90df2208bc8136e07645660e549
+  data.tar.gz: c4e1b2875eed5172569c7b9e5133fad415de2cf09848bf5b7d9d0a490ed9520bae21e0a208998b8756bebe05cadc8e2696245a691b2d2dbfbd606e0b12bdb4d8

data/lib/minecraft-query.rb

@@ -0,0 +1,25 @@
+module MinecraftQuery
+  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 = MCQuery::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,96 @@
+class MCQuery
+    require 'timeout'
+
+    def self.init
+        @sock = UDPSocket.new
+        @sock.connect(@addr,@port)
+        @val = {}
+        @buff = nil
+        key
+    end
+    
+    def self.key
+        begin
+            Timeout.timeout(1) 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 "Host unreachable, check your configuration and try again"
+            return "An Exception occured, please check last message"
+        rescue StandardError => e
+            return "An other error occured. Check your ruby installation and tell the tech monkey this:"
+            return e
+        end
+    end
+    
+    def self.simpleQuery(addr = 'localhost', port = 25565)
+        @addr = addr
+        @port = port
+        init 
+        begin
+            Timeout.timeout(1) do
+                query = @sock.send("\xFE\xFD\x00\x01\x02\x03\x04".force_encoding(Encoding::ASCII_8BIT) + @key.to_s, 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 e
+        end
+    end
+    
+    def self.fullQuery(addr = 'localhost', port = 25565)
+        @addr = addr
+        @port = port
+        init
+        begin
+            Timeout.timeout(1) do
+                query = @sock.send("\xFE\xFD\x00\x01\x02\x03\x04".force_encoding(Encoding::ASCII_8BIT) + @key.to_s + "\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
+            puts e
+            #return "An other error occured. Check your minecraft config and tell the tech monkey this:"
+            raise e
+        end
+    end
+end

data/lib/rcon/rcon.rb

@@ -0,0 +1,436 @@
+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
+    #
+    # NOTE: This file has not been updated since previous version. Please be aware there may be outstanding Ruby2 bugs
+
+    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-v2
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- MV Code Club
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-19 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: info@mvcodeclub.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/minecraft-query.rb
+- lib/query/query.rb
+- lib/rcon/rcon.rb
+homepage: https://github.com/mvcodeclub/minecraft-query
+licenses:
+- MIT
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Minecraft Querying lib
+test_files: []