frostbitten 0.1.0

data/ext/frostbitten/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+extension_name = 'native'
+dir_config(extension_name)
+create_makefile("frostbitten/#{extension_name}")

data/ext/frostbitten/frostbitten.h

@@ -0,0 +1,13 @@
+#ifndef frostbitten_h
+#define frostbitten_h
+#include <ruby.h>
+#include <ruby/io.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h> 
+extern VALUE m_frostbitten;
+void Init_frostbitten();
+#define OVERRIDE_IF_SET(options,name)   rb_funcall(options, rb_intern("has_key?"), 1, ID2SYM(rb_intern(#name))) == Qtrue ? \
+                                rb_hash_aref(options, ID2SYM(rb_intern(#name))) : name
+#endif
+

data/ext/frostbitten/header.c

@@ -0,0 +1,194 @@
+#include "frostbitten.h"
+#include "header.h"
+#include <ruby/io.h>
+VALUE c_frostbitten_header;
+
+
+VALUE frostbitten_header_parse_from_buffer(VALUE self, fb_packet_buffer *buffer) {
+	fb_header *header;
+	Data_Get_Struct(self, fb_header, header);
+    frostbitten_header_unpack(header, buffer->header);
+    return self;
+}
+
+VALUE frostbitten_header_get_sequence(VALUE self) {
+	fb_header *header;
+	Data_Get_Struct(self, fb_header, header);
+	return INT2NUM(header->sequence);
+}
+
+VALUE frostbitten_header_set_sequence(VALUE self, VALUE seq) {
+	fb_header *header;
+	Data_Get_Struct(self, fb_header, header);
+	header->sequence = NUM2INT(seq);
+	return frostbitten_header_get_sequence(self);
+}
+
+VALUE frostbitten_header_set_origin(VALUE self, VALUE origin) {
+	fb_header *header;
+	Data_Get_Struct(self, fb_header, header);
+	if ( ID2SYM(rb_intern("client")) == origin ) {
+		header->origin = 1;
+	} else if ID2SYM(rb_intern("server") == origin ) {
+		header->origin = 0;
+	} else {
+		rb_raise(rb_eTypeError, "must be either :client or :server");
+	}
+	return Qfalse;
+}
+
+VALUE frostbitten_header_get_origin(VALUE self) {
+	fb_header *header;
+	Data_Get_Struct(self, fb_header, header);
+	switch(header->origin) {
+		case 1:
+			return ID2SYM(rb_intern("client"));
+			break;
+
+		case 0:
+			return ID2SYM(rb_intern("server"));
+			break;
+	}
+	return Qnil;
+}
+
+VALUE frostbitten_header_get_response(VALUE self) {
+	fb_header *header;
+	Data_Get_Struct(self, fb_header, header);
+	if ( header->response == 0 ) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+VALUE frostbitten_header_set_response(VALUE self, VALUE response) {
+	if ( TYPE(response) != T_TRUE && TYPE(response) != T_FALSE) {
+		rb_raise(rb_eTypeError, "must be either true or false");
+	}
+
+	fb_header *header;
+	Data_Get_Struct(self, fb_header, header);
+	if ( response == Qtrue ) 
+		header->response = 1;
+	else {
+		header->response = 0;
+	}
+	return frostbitten_header_get_response(self);
+}
+
+uint32_t frostbitten_header_package(fb_header *header) {
+	uint32_t data = header->sequence;
+	if ( header->origin == 0 ) {
+		data |= 1 << 31;
+	} else { 
+		data &= ~(1 << 31);
+	}
+
+	if ( header->response != (( 1 << 30 ) & data) ) {
+		data ^= 1 << 30;
+	}
+
+	return data;
+}
+
+void frostbitten_header_unpack(fb_header *header, uint32_t val) {
+	header->sequence = (uint32_t)val & 0x3fffffff;
+	header->origin = (val & (1 << 31));
+	header->response = (val & (1 << 30));
+}
+
+VALUE frostbitten_header_write_to_io(VALUE self, VALUE io) {
+	fb_header *header;
+	Data_Get_Struct(self, fb_header, header);
+
+	rb_io_t *fptr;
+	GetOpenFile(io, fptr);
+	rb_io_check_writable(fptr);
+
+	FILE *fp = rb_io_stdio_file(fptr);
+
+	uint32_t val = frostbitten_header_package(header);
+	fwrite((const void*)&val,sizeof(uint32_t),1,fp);
+	return self;
+}
+
+VALUE frostbitten_header_cls_read_from_io(VALUE self, VALUE io) {
+	VALUE header = rb_obj_alloc(c_frostbitten_header);
+    rb_obj_call_init(header, 0, 0);
+    return frostbitten_header_read_from_io(header, io);
+}
+
+VALUE frostbitten_header_read_from_io(VALUE self, VALUE io) {
+	fb_header *header;
+	Data_Get_Struct(self, fb_header, header);
+
+	uint32_t val = 0;
+
+	rb_io_t *fptr;
+	GetOpenFile(io, fptr);
+	rb_io_check_readable(fptr);
+
+	FILE *fp = rb_io_stdio_file(fptr);
+	fread((void*)&val, sizeof(uint32_t),1, fp);
+    
+    frostbitten_header_unpack(header, val);
+    return self;
+}
+
+void frostbitten_header_deallocate(fb_header *header) {
+	header->sequence = 0;
+	header->origin = 0;
+	header->response = false;
+	ruby_xfree(header);
+}
+
+VALUE frostbitten_header_allocate (VALUE klass) {
+	fb_header *header = ruby_xmalloc(sizeof(fb_header));
+	return Data_Wrap_Struct(klass,NULL,frostbitten_header_deallocate, header);
+}
+
+VALUE frostbitten_header_init(int argc, VALUE *argv, VALUE self) {
+
+	fb_header *header;
+	Data_Get_Struct(self, fb_header, header);
+
+ 	VALUE options;
+    if (rb_scan_args(argc, argv, "01", &options) == 0)
+        options = Qnil;
+
+    VALUE sequence = INT2NUM(0);
+    VALUE origin = ID2SYM(rb_intern("client"));
+    VALUE response = Qfalse;
+
+	if (!NIL_P(options) && TYPE(options) == T_HASH) {
+		sequence = OVERRIDE_IF_SET(options,sequence);
+		origin = OVERRIDE_IF_SET(options,origin);	
+		response = OVERRIDE_IF_SET(options,response);		
+	}
+	frostbitten_header_set_sequence(self,sequence);
+	frostbitten_header_set_origin(self,origin);
+	frostbitten_header_set_response(self,response);
+		
+	return self;
+}
+
+void header_init() {
+	c_frostbitten_header = rb_define_class_under(m_frostbitten, "Header", rb_cObject);
+	rb_define_alloc_func(c_frostbitten_header, frostbitten_header_allocate);
+	rb_define_method(c_frostbitten_header, "initialize", frostbitten_header_init, -1);
+
+    rb_define_method(c_frostbitten_header,"sequence=", frostbitten_header_set_sequence,1);
+    rb_define_method(c_frostbitten_header,"sequence", frostbitten_header_get_sequence,0);
+    
+    rb_define_method(c_frostbitten_header, "origin", frostbitten_header_get_origin,0);
+    rb_define_method(c_frostbitten_header, "origin=", frostbitten_header_set_origin, 1);
+
+	rb_define_method(c_frostbitten_header,"response=", frostbitten_header_set_response, 1);
+    rb_define_method(c_frostbitten_header,"is_response?", frostbitten_header_get_response, 0);
+
+    rb_define_method(c_frostbitten_header, "read", frostbitten_header_read_from_io, 1);
+    rb_define_method(c_frostbitten_header, "write", frostbitten_header_write_to_io, 1);
+    rb_define_singleton_method(c_frostbitten_header, "read", frostbitten_header_cls_read_from_io, 1);
+
+}

data/ext/frostbitten/header.h

@@ -0,0 +1,30 @@
+#include "frostbitten.h"
+#include "packet.h"
+#ifndef header_h
+#define header_h
+
+extern VALUE c_frostbitten_header;
+
+typedef struct _fb_header {
+	uint32_t sequence;
+	uint32_t origin;
+	bool response;
+} fb_header;
+
+void header_init();
+VALUE frostbitten_header_parse_from_buffer(VALUE self, fb_packet_buffer *buffer);
+VALUE frostbitten_header_get_sequence(VALUE self);
+VALUE frostbitten_header_set_sequence(VALUE self, VALUE seq);
+uint32_t frostbitten_header_package(fb_header *header);
+void frostbitten_header_unpack(fb_header *header, uint32_t val);
+
+VALUE frostbitten_header_cls_read_from_io(VALUE self, VALUE io);
+VALUE frostbitten_header_read_from_io(VALUE self, VALUE io);
+VALUE frostbitten_header_write_to_io(VALUE self, VALUE io);
+// VALUE frostbitten_header_test_write(VALUE self);
+// VALUE frostbitten_header_test_read(VALUE self);
+VALUE frostbitten_header_format(VALUE self);
+void frostbitten_header_deallocate(fb_header *header);
+VALUE frostbitten_header_allocate (VALUE klass);
+
+#endif

data/ext/frostbitten/message.c

@@ -0,0 +1,202 @@
+#include "frostbitten.h"
+#include "message.h"
+
+VALUE c_frostbitten_message;
+
+void frostbitten_read_words_from_file(fb_message *message, FILE *fp, fb_packet_buffer *buffer) {
+	for(uint32_t i=0; i < buffer->wordCount; i++) {
+		uint32_t wordByteLength = 0;
+		fread(&wordByteLength, sizeof(uint32_t), 1, fp);
+
+		char *word = malloc(wordByteLength+1);
+		fread(word, sizeof(char), wordByteLength+1, fp);
+		rb_ary_push(message->words, rb_str_new2(word));
+	}
+}
+
+VALUE frostbitten_message_read_from_io(VALUE self, VALUE io) {
+	fb_message *message;
+	Data_Get_Struct(self, fb_message, message);
+
+	rb_io_t *fptr;
+	GetOpenFile(io, fptr);
+	rb_io_check_readable(fptr);
+	FILE *fp = rb_io_stdio_file(fptr);
+	fb_packet_buffer *buffer = read_buffer_from_io(fp);
+	
+	if ( !message->header ) {
+		message->header = rb_class_new_instance(0, NULL, c_frostbitten_header);
+		frostbitten_header_parse_from_buffer(message->header, buffer);
+	}
+   	
+   	frostbitten_read_words_from_file(message, fp, buffer);
+    return self;
+}
+
+VALUE frostbitten_message_cls_read_from_io(VALUE self, VALUE io) {
+	VALUE msg = rb_obj_alloc(c_frostbitten_message);
+    rb_obj_call_init(msg, 0, 0);
+    return frostbitten_message_read_from_io(msg, io);
+}
+
+VALUE frostbitten_message_complete(VALUE self, VALUE io) {
+	rb_io_t *fptr;
+	GetOpenFile(io, fptr);
+	rb_io_check_readable(fptr);
+	FILE *fp = rb_io_stdio_file(fptr);
+
+	fb_packet_buffer *buffer = read_buffer_from_io(fp);
+	if (is_packet_valid(buffer)) {
+		VALUE msg = rb_obj_alloc(c_frostbitten_message);
+    	rb_obj_call_init(msg, 0, 0);
+    	fb_message *message;
+		Data_Get_Struct(msg, fb_message, message);
+    	frostbitten_read_words_from_file(message, fp, buffer);
+
+		if (rb_block_given_p()) {
+			return rb_yield(msg);
+		} else {
+			return msg;
+		}
+	}
+	free(buffer);
+	return Qnil;
+}
+
+
+
+
+VALUE frostbitten_message_write_to_io(VALUE self, VALUE io) {
+	fb_message *message;
+	Data_Get_Struct(self, fb_message, message);
+
+	frostbitten_header_write_to_io(message->header, io);
+
+
+	uint32_t arrayLength = (uint32_t)RARRAY_LEN(message->words);
+	uint32_t packetSize = 0;
+
+	char** strings = frostbitten_message_generate(message, &packetSize);
+	packetSize += sizeof(uint32_t); // Header
+	packetSize += sizeof(uint32_t); // packetSize
+	packetSize += sizeof(uint32_t); // wordCount
+	rb_io_t *fptr;
+	GetOpenFile(io, fptr);
+	rb_io_check_readable(fptr);
+	FILE *fp = rb_io_stdio_file(fptr);
+
+	fwrite((const void*)&packetSize,sizeof(uint32_t),1,fp);
+	fwrite((const void*)&arrayLength,sizeof(uint32_t),1,fp);
+	for(uint32_t i=0; i < arrayLength; i++) {
+		char *str = strings[i];
+		uint32_t len = (uint32_t)strlen(str);
+		fwrite((const void*)&len, sizeof(uint32_t), 1, fp);
+		fwrite(str, sizeof(char), strlen(str)+1, fp);
+	}
+	fflush(fp);
+	return self;
+}
+
+char** frostbitten_message_generate(fb_message *message, uint32_t *message_size) {
+	uint32_t arrayLength = (uint32_t)RARRAY_LEN(message->words);
+	char **strings = (char **)calloc(arrayLength,sizeof(char *));
+
+	for(uint32_t i=0; i < arrayLength; i++) {
+		VALUE str = rb_ary_entry(message->words, i);
+		if ( !NIL_P(str) && TYPE(str) == T_STRING ) {
+			char *p = StringValueCStr(str);
+			char *p2 = malloc(strlen(p)*sizeof(char)+1);
+			memcpy(p2,p,strlen(p)*sizeof(char)+1);
+			strings[i] = p2;
+			*message_size += sizeof(char)*(strlen(p2)+1)+sizeof(uint32_t);
+		}
+	}
+	return strings;
+}
+
+VALUE frostbitten_message_get_words(VALUE self) {
+	fb_message *message;
+	Data_Get_Struct(self, fb_message, message);
+	return message->words;
+}
+
+VALUE frostbitten_message_set_words(VALUE self, VALUE words) {
+	Check_Type(words, T_ARRAY);
+
+	fb_message *message;
+	Data_Get_Struct(self, fb_message, message);
+	message->words = words;
+	return message->words;
+}
+
+VALUE frostbitten_message_get_header(VALUE self) {
+	fb_message *message;
+	Data_Get_Struct(self, fb_message, message);
+	return message->header;
+}
+
+VALUE frostbitten_message_set_header(VALUE self, VALUE header) {
+	if ( NIL_P(header) || CLASS_OF(header) != c_frostbitten_header ) {
+		rb_raise(rb_eTypeError, "Invalid argument header, not a Frostbitten::Header");
+		return Qnil;
+	}
+	fb_message *message;
+	Data_Get_Struct(self, fb_message, message);
+	message->header = header;
+	return message->header;
+}
+
+VALUE frostbitten_message_init(int argc, VALUE *argv, VALUE self) {
+
+	fb_message *message;
+	Data_Get_Struct(self, fb_message, message);
+
+ 	VALUE options;
+    if (rb_scan_args(argc, argv, "01", &options) == 0)
+        options = Qnil;
+    VALUE words = rb_ary_new();
+	VALUE header = rb_obj_alloc(c_frostbitten_header);
+
+	if (!NIL_P(options) && TYPE(options) == T_HASH) {
+		words = OVERRIDE_IF_SET(options,words);
+		header = OVERRIDE_IF_SET(options,header);
+	}
+
+	frostbitten_message_set_header(self,header);
+	frostbitten_message_set_words(self,words);
+		
+	return self;
+}
+
+void frostbitten_message_deallocate(fb_message *message) {
+	// frostbitten_header_deallocate(message->header);
+	ruby_xfree(message);
+}
+
+void frostbitten_message_mark(fb_message *message) {
+	rb_gc_mark(message->header);
+	rb_gc_mark(message->words);
+}
+
+
+VALUE frostbitten_message_allocate (VALUE klass) {
+	fb_message *msg = ruby_xmalloc(sizeof(fb_message));
+	return Data_Wrap_Struct(klass, frostbitten_message_mark, frostbitten_message_deallocate, msg);
+}
+
+void message_init() {
+	c_frostbitten_message = rb_define_class_under(m_frostbitten, "Message", rb_cObject);
+	rb_define_alloc_func(c_frostbitten_message, frostbitten_message_allocate);
+	rb_define_method(c_frostbitten_message, "initialize", frostbitten_message_init, -1);
+
+	rb_define_method(c_frostbitten_message, "write", frostbitten_message_write_to_io, 1);
+	rb_define_method(c_frostbitten_message, "read", frostbitten_message_read_from_io, 1);
+	
+	rb_define_method(c_frostbitten_message, "words", frostbitten_message_get_words, 0);
+	rb_define_method(c_frostbitten_message, "words=", frostbitten_message_set_words, 1);
+
+	rb_define_method(c_frostbitten_message, "header", frostbitten_message_get_header, 0);
+	rb_define_method(c_frostbitten_message, "header=", frostbitten_message_set_header, 1);
+	rb_define_singleton_method(c_frostbitten_message, "read", frostbitten_message_cls_read_from_io, 1);
+	rb_define_singleton_method(c_frostbitten_message, "locate_packet", frostbitten_message_complete, 1);
+}