frostbitten 0.1.0

data/ext/frostbitten/message.h

@@ -0,0 +1,17 @@
+#include "frostbitten.h"
+#include "word.h"
+#include "header.h"
+
+#ifndef message_h
+#define message_h
+void message_init();
+extern VALUE c_frostbitten_message;
+// Frostbitten::Message
+typedef struct _fb_message {
+	VALUE header; // Frostbitten::Header
+	VALUE words; // Array
+} fb_message;
+void frostbitten_message_deallocate(fb_message *message);
+VALUE frostbitten_message_allocate (VALUE klass);
+char** frostbitten_message_generate(fb_message *message, uint32_t *message_size);
+#endif

data/ext/frostbitten/native.c

@@ -0,0 +1,15 @@
+// Include the Ruby headers and goodies
+#include "frostbitten.h"
+#include "word.h"
+#include "header.h"
+#include "message.h"
+
+
+VALUE m_frostbitten;
+// // The initialization method for this module
+void Init_native() {
+	m_frostbitten = rb_define_module("Frostbitten");
+	header_init();
+ 	message_init();
+ 	word_init();
+}

data/ext/frostbitten/packet.c

@@ -0,0 +1,20 @@
+#include "packet.h"
+
+fb_packet_buffer* read_buffer_from_io(FILE *fp) {
+	fb_packet_buffer *buffer = malloc(sizeof(fb_packet_buffer));
+	fread((void*)&buffer->header, sizeof(uint32_t), 1, fp);
+	fread((void*)&buffer->packetSize, sizeof(uint32_t), 1, fp);
+	fread((void*)&buffer->wordCount, sizeof(uint32_t), 1, fp);
+	return buffer;
+}
+
+bool is_packet_valid(fb_packet_buffer *buffer) {
+	if ( !&buffer->header || !&buffer->packetSize ) {
+		return false;
+	}
+
+	if ( buffer->packetSize > 16384 ) {
+		return false;
+	}
+	return true;
+}

data/ext/frostbitten/packet.h

@@ -0,0 +1,11 @@
+#include "frostbitten.h"
+#ifndef packet_h
+#define packet_h
+typedef struct _fb_packet_buffer {
+	uint32_t header;
+	uint32_t packetSize;
+	uint32_t wordCount;
+} fb_packet_buffer;
+fb_packet_buffer* read_buffer_from_io(FILE *fp);
+bool is_packet_valid(fb_packet_buffer *buffer);
+#endif

data/ext/frostbitten/word.c

@@ -0,0 +1,60 @@
+#include "word.h"
+VALUE c_frostbitten_word;
+void frostbitten_word_deallocate(fb_word *word) {
+	word->len = 0;
+	memset(&word->str[0],0,sizeof(&word->str));
+	word->term = 0x0;
+	ruby_xfree(word);
+}
+
+VALUE frostbitten_word_read_from_io(VALUE self, VALUE io) {
+	fb_word *word;
+	Data_Get_Struct(self, fb_word, word);
+
+	rb_io_t *fptr;
+	GetOpenFile(io, fptr);
+	rb_io_check_readable(fptr);
+
+	FILE *fp = rb_io_stdio_file(fptr);
+	fread((void*)&word->len, sizeof(uint32_t),1, fp);
+	fread((void*)&word->str, sizeof(char),word->len, fp);
+	fread((void*)&word->term, sizeof(char), 1, fp);
+	printf("%s", word->str);
+    return self;
+}
+
+VALUE frostbitten_word_cls_read_from_io(VALUE self, VALUE io) {
+	return self;
+}
+
+VALUE frostbitten_word_write_to_io(VALUE self, VALUE io) {
+	fb_word *word;
+	Data_Get_Struct(self, fb_word, word);
+
+	rb_io_t *fptr;
+	GetOpenFile(io, fptr);
+	rb_io_check_writable(fptr);
+
+	FILE *fp = rb_io_stdio_file(fptr);
+	// fwrite((const void*)&val,sizeof(uint32_t),1,fp);
+
+	rb_io_bufwrite(io, (const void*)&word->len, sizeof(uint32_t));
+	rb_io_bufwrite(io, (const void*)&word->str, sizeof(uint32_t));
+	rb_io_bufwrite(io, (const void*)&word->len, sizeof(uint32_t));
+	return self;
+}
+
+VALUE frostbitten_word_allocate (VALUE klass) {
+	fb_word *word = ruby_xmalloc(sizeof(fb_word));
+	return Data_Wrap_Struct(klass, NULL, frostbitten_word_deallocate, word);
+}
+
+void word_init() {
+	c_frostbitten_word = rb_define_class_under(m_frostbitten, "Word", rb_cString);
+	rb_define_alloc_func(c_frostbitten_word, frostbitten_word_allocate);
+
+	rb_define_method(c_frostbitten_word, "read", frostbitten_word_read_from_io, 1);
+    rb_define_method(c_frostbitten_word, "write", frostbitten_word_write_to_io, 1);
+    rb_define_singleton_method(c_frostbitten_word, "read", frostbitten_word_cls_read_from_io, 1);
+
+}

data/ext/frostbitten/word.h

@@ -0,0 +1,17 @@
+#include "frostbitten.h"
+
+#ifndef word_h
+#define word_h
+
+extern VALUE c_frostbitten_word;
+void word_init();
+typedef struct _fb_word {
+	uint32_t len;
+	char str[INT_MAX];
+	char term;
+} fb_word;
+
+void frostbitten_word_deallocate(fb_word *word);
+VALUE frostbitten_word_allocate (VALUE klass);
+
+#endif

data/frostbitten.gemspec

@@ -0,0 +1,106 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "frostbitten"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Emil Palm"]
+  s.date = "2013-02-22"
+  s.description = "Gem that provides RCON commands for frostbite 2 engine games. BF3, BFBC2 and so on"
+  s.email = "emil.palm@x86.nu"
+  s.extensions = ["ext/frostbitten/extconf.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "Guardfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "ext/.DS_Store",
+    "ext/frostbitten/.DS_Store",
+    "ext/frostbitten/Makefile",
+    "ext/frostbitten/extconf.rb",
+    "ext/frostbitten/frostbitten.h",
+    "ext/frostbitten/header.c",
+    "ext/frostbitten/header.h",
+    "ext/frostbitten/message.c",
+    "ext/frostbitten/message.h",
+    "ext/frostbitten/native.c",
+    "ext/frostbitten/packet.c",
+    "ext/frostbitten/packet.h",
+    "ext/frostbitten/word.c",
+    "ext/frostbitten/word.h",
+    "frostbitten.gemspec",
+    "lib/frostbitten.rb",
+    "lib/frostbitten/client.rb",
+    "lib/frostbitten/connection.rb",
+    "lib/frostbitten/map.rb",
+    "lib/frostbitten/methods/admin.rb",
+    "lib/frostbitten/methods/normal.rb",
+    "lib/frostbitten/player.rb",
+    "lib/frostbitten/score.rb",
+    "lib/frostbitten/server.rb",
+    "lib/frostbitten/version.rb",
+    "spec/frostbitten_spec.rb",
+    "spec/lib/frostbitten_client_spec.rb",
+    "spec/lib/frostbitten_server_spec.rb",
+    "spec/spec_helper.rb",
+    "test/helper.rb",
+    "test/test_frostbitten.rb"
+  ]
+  s.homepage = "http://github.com/mrevilme/frostbitten"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "Gem that provides RCON commands for frostbite 2 engine games. BF3, BFBC2 and so on"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<hashie>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<rb-fsevent>, [">= 0"])
+      s.add_development_dependency(%q<guard-rspec>, [">= 0"])
+      s.add_development_dependency(%q<terminal-notifier-guard>, [">= 0"])
+      s.add_development_dependency(%q<rake-compiler>, [">= 0"])
+    else
+      s.add_dependency(%q<hashie>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<rb-fsevent>, [">= 0"])
+      s.add_dependency(%q<guard-rspec>, [">= 0"])
+      s.add_dependency(%q<terminal-notifier-guard>, [">= 0"])
+      s.add_dependency(%q<rake-compiler>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<hashie>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<rb-fsevent>, [">= 0"])
+    s.add_dependency(%q<guard-rspec>, [">= 0"])
+    s.add_dependency(%q<terminal-notifier-guard>, [">= 0"])
+    s.add_dependency(%q<rake-compiler>, [">= 0"])
+  end
+end
+

data/lib/frostbitten.rb

@@ -0,0 +1,37 @@
+require 'frostbitten/native'
+require 'frostbitten/version'
+require 'frostbitten/connection'
+require 'frostbitten/client'
+require 'frostbitten/player'
+require 'frostbitten/server'
+require 'frostbitten/score'
+require 'frostbitten/map'
+
+# Author::    Emil Palm  (mailto:emil@x86.nu)
+# Copyright:: Copyright (c) 2013 Emil Palm
+# License::   Distributes under the same terms as Ruby
+
+# This module will give you a shorthand to a client object.
+# very useful if your only connecting to one server
+
+module Frostbitten
+	# Setup the module with a URI 'fbrcon://password@ip:port'
+	# Also accepts options { :keepalive = true/false, :socket_timeout => 1 }
+	def self.setup(uri,options={})
+		@client = Frostbitten::Client.new(uri,options)
+	end
+
+	# Method to return the client object if raw access is needed
+	def self.conn
+		return @client
+	end
+
+	# :nodoc:
+	def self.method_missing(meth, *args, &block) 
+		if @client and @client.respond_to?(meth)
+			@client.public_send(meth, *args, &block)
+		else
+			super
+		end
+	end
+end

data/lib/frostbitten/client.rb

@@ -0,0 +1,50 @@
+require 'digest/md5'
+require 'frostbitten/methods/admin'
+require 'frostbitten/methods/normal'
+
+# Author::    Emil Palm  (mailto:emil@x86.nu)
+# Copyright:: Copyright (c) 2013 Emil Palm
+# License::   Distributes under the same terms as Ruby
+
+# This class will give you a shorthand to a Server object.
+# and give you a easy way to execute methods on server
+# that are predefined in this class.
+
+module Frostbitten
+	class Client
+		# Access to the server object.
+		attr_accessor :connection
+
+		# Initialize class with URI 'fbrcon://password@ip:port'
+		# Also accept options
+		# { :keepalive = true/false, :socket_timeout => 1 }
+		# will setup connection object.
+		def initialize(uri=nil, options={})
+			if uri
+				self.connection = Frostbitten::Connection.new(uri,options)
+			end
+		end
+
+		# Will create Frostbitten::Header and Frostbitten::Message 
+		# objects for given commands. 
+		# Accepts either a string or a array of strings to send.
+		# Returns a list of words returned by server.
+		def send(commands)
+			return unless self.connection
+
+			if commands.is_a? String
+				commands = [commands]
+			end
+
+			header = Frostbitten::Header.new(:origin => :client, :response => false)
+			msg = Frostbitten::Message.new(:words => commands, :header => header)
+			message = connection.send(msg)
+			return message.words[1..-1]
+		end
+
+		include Frostbitten::Methods::AdminCommands
+		include Frostbitten::Methods::NormalCommands
+		# :include:methods/admin.rb
+		# :include:methods/normal.rb
+	end
+end

data/lib/frostbitten/connection.rb

@@ -0,0 +1,100 @@
+require 'uri/generic'
+require 'socket'
+module URI
+	class FrostbiteRCON < Generic
+		COMPONENT = [:scheme,:host,:port]
+	end
+  	@@schemes['fbrcon'] = FrostbiteRCON
+end
+
+module Frostbitten
+	class Connection
+		DEFAULTS = {
+			# connect/read/write timeout for socket operations
+			:socket_timeout => 0.5,
+			
+			:keepalive => true
+		}
+
+		attr_accessor :hostname, :port, :password
+		attr_reader :sock, :sequence, :timeout
+
+		# Initialize class with URI 'fbrcon://password@ip:port'
+		# Also accept options
+		# { :keepalive = true/false, :socket_timeout => 1 }
+
+		def initialize(uri, options={})
+			server_parsed = URI.parse(uri)
+			self.hostname = server_parsed.host
+			self.password = server_parsed.user
+			self.port = server_parsed.port ||= 47200
+
+			@sock = nil 
+			@sequence = options[:sequence] ||= 0
+
+			@options = DEFAULTS.merge(options)
+		end
+
+		# Returns if the socket is alive of closed
+		def alive?
+			return true if @sock
+			return false
+		end
+
+		# Connects socket
+		def connect
+			return if alive?
+			@sock = TCPSocket.open(self.hostname, self.port);
+			if @options[:socket_timeout]
+        		secs = Integer(@options[:socket_timeout])
+        		usecs = Integer((@options[:socket_timeout] - secs) * 1_000_000)
+        		optval = [secs, usecs].pack("l_2")
+        		@sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+        		@sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+      		end
+
+      		if @options[:keepalive]
+      			@sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+      		end
+		end
+
+		# Close socket
+		def close
+			return unless alive?
+			@sock.close
+			@sock = nil
+		end
+
+
+		# Accepts a Frostbitten::Mesage and sends it over socket
+		# updates message.header.sequence with a incremented version
+		# of server sequence counter.
+		# can raise NameError, ArgumentError or StandardError based on return data
+		# from server.
+		def send(message) 
+			connect unless self.alive?
+			unless message.header.is_response?
+				@sequence += 1
+			end
+
+			message.header.sequence = self.sequence
+			message.write @sock
+
+			m = Message.new()
+			m.read @sock
+
+			unless m.words.first == "OK"
+				m.words.first.tap do |word|
+				 	if word == "UnknownCommand"
+				 		raise NameError, "UnknownCommand raised by server"
+				 	elsif word == "InvalidArguments"
+				 		raise ArgumentError, "InvalidArguments raised by server"
+				 	else
+				 		raise StandardError, "Server returned #{word}"
+				 	end
+				 end
+			end
+			return m
+		end
+	end
+end