lwes 0.1.0

data/ext/lwes/lwes.c

@@ -0,0 +1,27 @@
+#include "lwes_ruby.h"
+
+static VALUE mLWES;
+
+/* initialize the extension, Ruby automatically picks this up */
+void Init_lwes_ext(void)
+{
+	mLWES = rb_define_module("LWES");
+
+	#define LWES_TYPE_CONST(name) \
+	   rb_define_const(mLWES, #name, INT2FIX(LWES_TYPE_##name))
+	LWES_TYPE_CONST(U_INT_16);
+	LWES_TYPE_CONST(INT_16);
+	LWES_TYPE_CONST(U_INT_32);
+	LWES_TYPE_CONST(INT_32);
+	LWES_TYPE_CONST(U_INT_64);
+	LWES_TYPE_CONST(INT_64);
+	LWES_TYPE_CONST(BOOLEAN);
+	LWES_TYPE_CONST(IP_ADDR);
+	LWES_TYPE_CONST(STRING);
+	LWES_TYPE_CONST(UNDEFINED);
+	#undef LWES_TYPE_CONST
+
+	lwesrb_init_numeric();
+	lwesrb_init_emitter();
+	lwesrb_init_type_db();
+}

data/ext/lwes/lwes_ruby.h

@@ -0,0 +1,40 @@
+#ifndef LWES_RUBY_H
+#define LWES_RUBY_H
+
+#include <lwes.h>
+#include <ruby.h>
+#include <assert.h>
+#include <stdint.h>
+
+#define LWESRB_MKSYM(SYM) sym_##SYM = ID2SYM(rb_intern(#SYM))
+
+struct lwes_event_type_db * lwesrb_get_type_db(VALUE self);
+
+void lwesrb_init_type_db(void);
+
+void lwesrb_init_emitter(void);
+
+void lwesrb_init_numeric(void);
+
+int lwesrb_event_set_numeric(
+	struct lwes_event *event,
+	LWES_CONST_SHORT_STRING name,
+	VALUE array);
+
+int lwesrb_event_set_num(
+	struct lwes_event *event,
+	LWES_CONST_SHORT_STRING name,
+	LWES_TYPE type,
+	VALUE val);
+
+#ifndef RSTRING_PTR
+#  define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#  define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#ifndef RARRAY_PTR
+#  define RARRAY_PTR(s) (RARRAY(s)->ptr)
+#  define RARRAY_LEN(s) (RARRAY(s)->len)
+#endif
+
+#endif /* LWES_RUBY_H */

data/ext/lwes/numeric.c

@@ -0,0 +1,207 @@
+#include "lwes_ruby.h"
+#include <arpa/inet.h>
+
+static ID
+  sym_int16, sym_uint16,
+  sym_int32, sym_uint32,
+  sym_int64, sym_uint64,
+  sym_ip_addr;
+
+static int set_uint16(
+	struct lwes_event *event, LWES_CONST_SHORT_STRING name, VALUE val)
+{
+	int32_t tmp = NUM2INT(val);
+
+	if (tmp < 0)
+		rb_raise(rb_eRangeError, ":uint16 negative: %d", tmp);
+	if (tmp > UINT16_MAX)
+		rb_raise(rb_eRangeError, ":uint16 too large: %d", tmp);
+
+	return lwes_event_set_U_INT_16(event, name, (LWES_U_INT_16)tmp);
+}
+
+static int set_int16(
+	struct lwes_event *event, LWES_CONST_SHORT_STRING name, VALUE val)
+{
+	int tmp = NUM2INT(val);
+
+	if (tmp > INT16_MAX)
+		rb_raise(rb_eRangeError, ":int16 too large: %i", tmp);
+	if (tmp < INT16_MIN)
+		rb_raise(rb_eRangeError, ":int16 too small: %i", tmp);
+
+	return lwes_event_set_INT_16(event, name, (LWES_INT_16)tmp);
+}
+
+static int set_uint32(
+	struct lwes_event *event, LWES_CONST_SHORT_STRING name, VALUE val)
+{
+	LONG_LONG tmp = NUM2LL(val);
+
+	if (tmp < 0)
+		rb_raise(rb_eRangeError, ":uint32 negative: %lli", tmp);
+	if (tmp > UINT32_MAX)
+		rb_raise(rb_eRangeError, ":uint32 too large: %lli", tmp);
+
+	return lwes_event_set_U_INT_32(event, name, (LWES_U_INT_32)tmp);
+}
+
+static int set_int32(
+	struct lwes_event *event, LWES_CONST_SHORT_STRING name, VALUE val)
+{
+	LONG_LONG tmp = NUM2LL(val);
+
+	if (tmp > INT32_MAX)
+		rb_raise(rb_eRangeError, ":int32 too large: %lli", tmp);
+	if (tmp < INT32_MIN)
+		rb_raise(rb_eRangeError, ":int32 too small: %lli", tmp);
+
+	return lwes_event_set_INT_32(event, name, (LWES_INT_32)tmp);
+}
+
+static int set_uint64(
+	struct lwes_event *event, LWES_CONST_SHORT_STRING name, VALUE val)
+{
+	unsigned LONG_LONG tmp = NUM2ULL(val); /* can raise RangeError */
+	ID type = TYPE(val);
+
+	if ((type == T_FIXNUM && FIX2LONG(val) < 0) ||
+	    (type == T_BIGNUM && RTEST(rb_funcall(val, '<', 1, INT2FIX(0)))))
+		rb_raise(rb_eRangeError, ":uint64 negative: %s",
+		         RSTRING_PTR(rb_inspect(val)));
+
+	return lwes_event_set_U_INT_64(event, name, (LWES_U_INT_64)tmp);
+}
+
+static int set_int64(
+	struct lwes_event *event, LWES_CONST_SHORT_STRING name, VALUE val)
+{
+	LONG_LONG tmp = NUM2LL(val); /* can raise RangeError */
+
+	return lwes_event_set_INT_64(event, name, (LWES_INT_64)tmp);
+}
+
+static int set_ip_addr(
+	struct lwes_event *event, LWES_CONST_SHORT_STRING name, VALUE val)
+{
+	switch (TYPE(val)) {
+	case T_STRING:
+	{
+		LWES_CONST_SHORT_STRING addr = RSTRING_PTR(val);
+		return lwes_event_set_IP_ADDR_w_string(event, name, addr);
+	}
+	case T_FIXNUM:
+	case T_BIGNUM:
+	{
+		LWES_IP_ADDR *addr = ALLOC(LWES_IP_ADDR); /* never fails */
+		int rv;
+
+		addr->s_addr = htonl(NUM2UINT(val));
+		rv = lwes_event_set_IP_ADDR(event, name, *addr);
+
+		if (rv < 0)
+			xfree(addr);
+		return rv;
+	}
+	default:
+		rb_raise(rb_eTypeError,
+		         ":ip_addr address must be String or Integer: %s",
+		         RSTRING_PTR(rb_inspect(val)));
+	}
+}
+
+/* simple type => function dispatch map */
+static struct _type_fn_map {
+	ID type;
+	int (*fn)(struct lwes_event *, LWES_CONST_SHORT_STRING, VALUE);
+} type_fn_map[] = {
+#define SYMFN(T) { (ID)&sym_##T, set_##T }
+	SYMFN(uint16),
+	SYMFN(int16),
+	SYMFN(uint32),
+	SYMFN(int32),
+	SYMFN(uint64),
+	SYMFN(int64),
+	SYMFN(ip_addr),
+#undef SYMFN
+};
+
+int lwesrb_event_set_num(
+	struct lwes_event *event,
+	LWES_CONST_SHORT_STRING name,
+	LWES_TYPE type,
+	VALUE val)
+{
+	switch (type) {
+	case LWES_TYPE_U_INT_16: return set_uint16(event, name, val);
+	case LWES_TYPE_INT_16: return set_int16(event, name, val);
+	case LWES_TYPE_U_INT_32: return set_uint32(event, name, val);
+	case LWES_TYPE_INT_32: return set_int32(event, name, val);
+	case LWES_TYPE_U_INT_64: return set_uint64(event, name, val);
+	case LWES_TYPE_INT_64: return set_int64(event, name, val);
+	case LWES_TYPE_IP_ADDR: return set_ip_addr(event, name, val);
+	default:
+		rb_raise(rb_eRuntimeError,
+			 "unknown LWES attribute type: 0x%02x", type);
+	}
+	assert("you should never get here (set_field)");
+	return -1;
+}
+
+/*
+ * array contains two elements:
+ *   [ symbolic_type, number ]
+ * returns the return value of the underlying lwes_event_set_* call
+ */
+int lwesrb_event_set_numeric(
+	struct lwes_event *event,
+	LWES_CONST_SHORT_STRING name,
+	VALUE array)
+{
+	int i;
+	struct _type_fn_map *head;
+	VALUE *ary;
+	ID type;
+
+	assert(TYPE(array) == T_ARRAY && "need array here");
+
+	if (RARRAY_LEN(array) != 2)
+		rb_raise(rb_eArgError, "expected a two element array");
+
+	ary = RARRAY_PTR(array);
+	type = ary[0];
+
+	i = sizeof(type_fn_map) / sizeof(type_fn_map[0]);
+	for (head = type_fn_map; --i >= 0; head++) {
+		if (head->type == type)
+			return head->fn(event, name, ary[1]);
+	}
+
+	rb_raise(rb_eArgError,
+	         "unknown type: %s",
+	         RSTRING_PTR(rb_inspect(type)));
+
+	return -1;
+}
+
+void lwesrb_init_numeric(void)
+{
+	int i;
+
+	LWESRB_MKSYM(int16);
+	LWESRB_MKSYM(uint16);
+	LWESRB_MKSYM(int32);
+	LWESRB_MKSYM(uint32);
+	LWESRB_MKSYM(int64);
+	LWESRB_MKSYM(uint64);
+	LWESRB_MKSYM(ip_addr);
+
+	/*
+	 * we needed to have constants for compilation, so we set the
+	 * address of the IDs and then dereference + reassign them
+	 * at initialization time:
+	 */
+	i = sizeof(type_fn_map) / sizeof(type_fn_map[0]);
+	while (--i >= 0)
+		type_fn_map[i].type = *(ID *)type_fn_map[i].type;
+}

data/ext/lwes/type_db.c

@@ -0,0 +1,147 @@
+#include "lwes_ruby.h"
+
+static VALUE cLWES_TypeDB;
+
+struct _tdb {
+	struct lwes_event_type_db *db;
+};
+
+static void tdb_free(void *ptr)
+{
+	struct _tdb *tdb = ptr;
+
+	if (tdb->db)
+		lwes_event_type_db_destroy(tdb->db);
+	tdb->db = NULL;
+}
+
+static VALUE tdb_alloc(VALUE klass)
+{
+	struct _tdb *tdb;
+
+	return Data_Make_Struct(klass, struct _tdb, NULL, tdb_free, tdb);
+}
+
+static VALUE tdb_init(VALUE self, VALUE path)
+{
+	struct _tdb *tdb;
+
+	Data_Get_Struct(self, struct _tdb, tdb);
+	if (tdb->db)
+		rb_raise(rb_eRuntimeError, "ESF already initialized");
+
+	tdb->db = lwes_event_type_db_create(RSTRING_PTR(path));
+	if (!tdb->db)
+		rb_raise(rb_eRuntimeError,
+		         "failed to create type DB for LWES file %s",
+		         RSTRING_PTR(path));
+
+	return Qnil;
+}
+
+static VALUE attr_sym(struct lwes_event_attribute *attr)
+{
+	switch (attr->type) {
+	case LWES_TYPE_U_INT_16:
+	case LWES_TYPE_INT_16:
+	case LWES_TYPE_U_INT_32:
+	case LWES_TYPE_INT_32:
+	case LWES_TYPE_U_INT_64:
+	case LWES_TYPE_INT_64:
+	case LWES_TYPE_BOOLEAN:
+	case LWES_TYPE_IP_ADDR:
+	case LWES_TYPE_STRING:
+		return INT2NUM(attr->type);
+	case LWES_TYPE_UNDEFINED:
+	default:
+		rb_raise(rb_eRuntimeError,
+			 "unknown LWES attribute type: 0x%02x", attr->type);
+	}
+
+	return Qfalse;
+}
+
+static VALUE event_def_ary(struct lwes_hash *hash)
+{
+	struct lwes_hash_enumeration e;
+	VALUE rv = rb_ary_new();
+
+	if (!lwes_hash_keys(hash, &e))
+		rb_raise(rb_eRuntimeError, "couldn't get event attributes");
+	while (lwes_hash_enumeration_has_more_elements(&e)) {
+		LWES_SHORT_STRING key = lwes_hash_enumeration_next_element(&e);
+		struct lwes_event_attribute *attr;
+		VALUE pair;
+
+		if (!key)
+			rb_raise(rb_eRuntimeError,
+			         "LWES event type iteration key fail");
+
+		attr = (struct lwes_event_attribute *)lwes_hash_get(hash, key);
+		if (!attr)
+			rb_raise(rb_eRuntimeError,
+			         "LWES event type iteration value fail");
+
+		pair = rb_ary_new3(2, ID2SYM(rb_intern(key)), attr_sym(attr));
+		rb_ary_push(rv, pair);
+	}
+
+	return rv;
+}
+
+struct lwes_event_type_db * lwesrb_get_type_db(VALUE self)
+{
+	struct _tdb *tdb;
+
+	Data_Get_Struct(self, struct _tdb, tdb);
+	if (!tdb->db)
+		rb_raise(rb_eRuntimeError,
+		         "couldn't get lwes_type_db from %s",
+		         RSTRING_PTR(rb_inspect(self)));
+
+	return tdb->db;
+}
+
+static VALUE tdb_to_hash(VALUE self)
+{
+	struct _tdb *tdb;
+	VALUE rv = rb_hash_new();
+	struct lwes_hash *events;
+	struct lwes_hash_enumeration e;
+
+	Data_Get_Struct(self, struct _tdb, tdb);
+	assert(tdb->db && tdb->db->events && "tdb not initialized");
+	events = tdb->db->events;
+
+	if (!lwes_hash_keys(events, &e))
+		rb_raise(rb_eRuntimeError, "couldn't get type_db events");
+
+	while (lwes_hash_enumeration_has_more_elements(&e)) {
+		struct lwes_hash *hash;
+		ID event_key;
+		LWES_SHORT_STRING key = lwes_hash_enumeration_next_element(&e);
+
+		if (!key)
+			rb_raise(rb_eRuntimeError,
+			         "LWES type DB rv iteration key fail");
+
+		hash = (struct lwes_hash*)lwes_hash_get(events, key);
+		if (!hash)
+			rb_raise(rb_eRuntimeError,
+			         "LWES type DB rv iteration value fail");
+
+		event_key = ID2SYM(rb_intern(key));
+		rb_hash_aset(rv, event_key, event_def_ary(hash));
+	}
+
+	return rv;
+}
+
+void lwesrb_init_type_db(void)
+{
+	VALUE mLWES = rb_define_module("LWES");
+	cLWES_TypeDB = rb_define_class_under(mLWES, "TypeDB", rb_cObject);
+	rb_define_method(cLWES_TypeDB, "initialize", tdb_init, 1);
+	rb_define_method(cLWES_TypeDB, "to_hash", tdb_to_hash, 0);
+	rb_define_alloc_func(cLWES_TypeDB, tdb_alloc);
+}

data/lib/lwes.rb

@@ -0,0 +1,6 @@
+module LWES
+  autoload :TypeDB, "lwes/type_db"
+  autoload :Struct, "lwes/struct"
+  autoload :Emitter, "lwes/emitter"
+end
+require "lwes_ext"

data/lib/lwes/emitter.rb

@@ -0,0 +1,19 @@
+module LWES
+  class Emitter
+
+    # creates a new Emitter object which may be used for the lifetime
+    # of the process:
+    #
+    #   LWES::Emitter.new(:address => '224.1.1.11',
+    #                     :iface => '0.0.0.0',
+    #                     :port => 12345,
+    #                     :heartbeat => false, # Integer for frequency
+    #                     :ttl => 60, # nil for no ttl)
+    #
+    def initialize(options = {}, &block)
+      options[:iface] ||= '0.0.0.0'
+      _create(options)
+      block_given?
+    end
+  end
+end