intruder 0.1.0 → 0.2.0

data/README.md

@@ -12,27 +12,45 @@ Want to try?
 the test script makes an rpc call to a rabbitmq server and queries for its status.
 
 * checkout the source
-* `./configure`
+* `ruby extconf.rb`
 * start your rabbitmq server `sudo rabbitmq-server`
-* `ruby test.rb`
+* `ruby examples/rabbitmq_status_rpc.rb`
 
 the script should print something similar to this:
-    rabbit call
+    --- rabbit call ---
     sending params: []
     rpc call to rabbit:status
-    rpc response: [{running_applications, [{rabbit, "RabbitMQ", "1.7.2"}, {mnesia, "MNESIA  CXC 138 12", "4.4.13"}, {os_mon, "CPO  CXC 138 46", "2.2.5"}, {sasl, "SASL  CXC 138 11", "2.1.9"}, {stdlib, "ERTS  CXC 138 10", "1.16.5"}, {kernel, "ERTS  CXC 138 10", "2.13.5"}]}, {nodes, [rabbit@codeslave]}, {running_nodes, [rabbit@codeslave]}]
+    [{running_applications, [{rabbit, "RabbitMQ", "1.7.2"}, {mnesia, "MNESIA  CXC 138 12", "4.4.13"}, {os_mon, "CPO  CXC 138 46", "2.2.5"}, {sasl, "SASL  CXC 138 11", "2.1.9"}, {stdlib, "ERTS  CXC 138 10", "1.16.5"}, {kernel, "ERTS  CXC 138 10", "2.13.5"}]}, {nodes, ['rabbit@codeslave']}, {running_nodes, ['rabbit@codeslave']}]
+    Intruder::List
+
+    --- length of the response ---
+    Members: 3
+
+    --- print every member with its class ---
+    {running_applications, [{rabbit, "RabbitMQ", "1.7.2"}, {mnesia, "MNESIA  CXC 138 12", "4.4.13"}, {os_mon, "CPO  CXC 138 46", "2.2.5"}, {sasl, "SASL  CXC 138 11", "2.1.9"}, {stdlib, "ERTS  CXC 138 10", "1.16.5"}, {kernel, "ERTS  CXC 138 10", "2.13.5"}]} class: Intruder::Tuple
+    {nodes, ['rabbit@codeslave']} class: Intruder::Tuple
+    {running_nodes, ['rabbit@codeslave']} class: Intruder::Tuple
+
+    --- access the second element and print its size ---
+    {running_nodes, ['rabbit@codeslave']} has size 2
+
+    --- access the first element of the second member ---
+    nodes
+
+    --- which is a ---
+    Intruder::Atom
 
 Why that?
 =========
 
-because thats a fun project to learn c :)
+because thats a fun project to learn c and I need it for another project of mine (namely: paukul/humpty)
 
 What works already?
 ===================
 
-not much
+description missing... yet :)
 
 Erlix?
 ======
 
-is great, took some stuff from there, as I said, thats a fun project for me to learn more about c and c ruby extensions
+is great, I also took some stuff from them. Afaik, Erlix uses erl_interface for most of its operations. erl_interface is limited to one connection only, I needed something to open multiple connections to multiple queues. Erlix is able to do a LOT more than Intruder at the moment, make sure to check it out as well!

data/extconf.rb

@@ -0,0 +1,21 @@
+require 'mkmf'
+
+extension_name = 'intruder_ext'
+src_dir = File.expand_path('../src', __FILE__)
+findei = File.expand_path("../findei.erl", __FILE__)
+
+dir_config(extension_name)
+File.chmod(0755, findei)
+
+ei_dir = `#{findei}`.chomp
+include_dir = ei_dir + '/include/'
+lib_dir = ei_dir + '/lib/'
+
+$LDFLAGS << " -L#{lib_dir} -lei -lerl_interface"
+$CPPFLAGS << ' -D_REENTRANT -g -g3 -gdwarf-2'
+
+if find_header('ei.h', include_dir)
+  create_makefile(extension_name, src_dir)
+else
+  puts "error: erl_interface not found!"
+end

data/findei.erl

@@ -0,0 +1,6 @@
+#!/usr/bin/env escript
+%%% Author : KDr2
+%%% Find the location of erl_interface.
+
+main(_) ->
+    io:format("~s~n", [code:lib_dir(erl_interface)]).

data/lib/intruder.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../../intruder_ext', __FILE__)
+
+module Intruder
+
+  class Node
+    def mod(mod_name)
+      Mod.new(mod_name, self)
+    end
+  end
+
+  class Mod
+
+    private
+
+    def method_missing(method, *args)
+      rpc(method.to_s, *args)
+    end
+  end
+
+end

data/src/atom.c

@@ -0,0 +1,7 @@
+#include "atom.h"
+
+VALUE IntruderAtom = Qnil;
+
+void Init_intruder_atom() {
+  IntruderAtom = rb_define_class_under(IntruderModule, "Atom", IntruderTerm);
+}

data/src/atom.h

@@ -0,0 +1,12 @@
+#ifndef INTRUDER_ATOM_H
+#define INTRUDER_ATOM_H
+
+#include "ruby.h"
+#include "term.h"
+
+extern VALUE IntruderModule;
+extern VALUE IntruderTerm;
+
+void Init_intruder_atom();
+
+#endif

data/src/binary.c

@@ -0,0 +1,20 @@
+#include "binary.h"
+
+VALUE IntruderBinary = Qnil;
+
+void Init_intruder_binary() {
+  IntruderBinary = rb_define_class_under(IntruderModule, "Binary", IntruderTerm);
+
+  /* class methods */
+  rb_define_method(IntruderBinary, "initialize", intruder_binary_init, 1);
+}
+
+VALUE intruder_binary_init(VALUE self, VALUE str) {
+  ETERM *eterm;
+  INTRUDER_TERM *iterm;
+  Data_Get_Struct(self, INTRUDER_TERM, iterm);
+
+  eterm = erl_mk_binary(RSTRING_PTR(str), RSTRING_LEN(str));
+  iterm->eterm = eterm;
+  return self;
+}

data/src/binary.h

@@ -0,0 +1,13 @@
+#ifndef INTRUDER_BINARY_H
+#define INTRUDER_BINARY_H
+
+#include "ruby.h"
+#include "term.h"
+
+extern VALUE IntruderModule;
+extern VALUE IntruderTerm;
+
+void Init_intruder_binary();
+VALUE intruder_binary_init(VALUE self, VALUE str);
+
+#endif /* INTRUDER_BINARY_H */

data/src/erlix_helper.c

@@ -0,0 +1,165 @@
+/*
+ * taken from erlix erlix
+ * http://github.com/KDr2/erlix
+ */
+
+#include "erlix_helper.h"
+
+static int  is_printable_list(const ETERM* term);
+static void fill_printable_list(VALUE *str, const ETERM* ep);
+
+static int is_printable_list(const ETERM* term)
+{
+  while (ERL_TYPE(term) == ERL_LIST) {
+    ETERM* head = (ETERM*)(ERL_CONS_HEAD(term));
+    if (ERL_INT_VALUE(head) < 0 || ERL_INT_VALUE(head) > 255) {
+      return 0;
+    }
+    if (ERL_INT_VALUE(head) < ' ') {
+      switch (ERL_INT_VALUE(head)) {
+      case '\n':
+      case '\r':
+      case '\t':
+      case '\v':
+      case '\b':
+      case '\f':
+        break;
+      default:
+        return 0;
+      }
+    }
+    term = (ETERM*)(ERL_CONS_TAIL(term));
+  }
+  return ERL_IS_EMPTY_LIST(term);
+}
+
+static void fill_printable_list(VALUE *str, const ETERM* ep){
+  ID concat=rb_intern("concat");
+/*   rb_funcall(*str,concat,1,rb_str_new2("\"")); */
+
+  while (ERL_IS_CONS(ep)) {
+    int c = ERL_INT_VALUE((ETERM*)ERL_CONS_HEAD(ep));
+    if (c >= ' ') {
+      char tmp_buf[2];
+      tmp_buf[0]=c;
+      tmp_buf[1]=0;
+      rb_funcall(*str,concat,1,rb_str_new2(tmp_buf));
+    }
+    else {
+      if(c=='\n'){
+        rb_funcall(*str,concat,1,rb_str_new2("\\n"));
+      }else if(c=='\r'){
+        rb_funcall(*str,concat,1,rb_str_new2("\\r"));
+      }else if(c=='\t'){
+        rb_funcall(*str,concat,1,rb_str_new2("\\t"));
+      }else if(c=='\v'){
+        rb_funcall(*str,concat,1,rb_str_new2("\\v"));
+      }else if(c=='\b'){
+        rb_funcall(*str,concat,1,rb_str_new2("\\b"));
+      }else if(c=='\f'){
+        rb_funcall(*str,concat,1,rb_str_new2("\\f"));
+      }else{
+        char tmp_buf[8];
+        memset(tmp_buf,0,8);
+        sprintf(tmp_buf,"\\%o",c);
+        rb_funcall(*str,concat,1,rb_str_new2(tmp_buf));
+      }
+    }
+    ep = (ETERM*)ERL_CONS_TAIL(ep);
+  }
+/*   rb_funcall(*str,concat,1,rb_str_new2("\"")); */
+}
+
+void fill_string(VALUE *str,ETERM *ep){
+  ID concat=rb_intern("concat");
+
+  int j,i,doquote;
+  if (!ep) return;
+
+  j = i = doquote = 0;
+
+  if(ERL_IS_ATOM(ep)){
+    /* FIXME: what if some weird locale is in use? */
+    if (!islower((int)ERL_ATOM_PTR(ep)[0]))
+      doquote = 1;
+    for (i = 0; !doquote && i < ERL_ATOM_SIZE(ep); i++){
+      doquote = !(isalnum((int)ERL_ATOM_PTR(ep)[i])
+                  || (ERL_ATOM_PTR(ep)[i] == '_'));
+    }
+    if (doquote) {
+      rb_funcall(*str,concat,1,rb_str_new2("\'"));
+    }
+    rb_funcall(*str,concat,1,rb_str_new2(ERL_ATOM_PTR(ep)));
+    if(doquote){
+      rb_funcall(*str,concat,1,rb_str_new2("\'"));
+    }
+  }else if(ERL_IS_PID(ep)){
+    int buffsize = 9 + strlen(ERL_PID_NODE(ep));
+    char tmp_buf_pid[buffsize];
+    memset(tmp_buf_pid,0,buffsize);
+    sprintf(tmp_buf_pid,"<%s.%d.%d>",ERL_PID_NODE(ep),ERL_PID_NUMBER(ep), ERL_PID_SERIAL(ep));
+    rb_funcall(*str,concat,1,rb_str_new2(tmp_buf_pid));
+  }else if(ERL_IS_PORT(ep)){
+    rb_funcall(*str,concat,1,rb_str_new2("#Port"));
+  }else if(ERL_IS_REF(ep)){
+    rb_funcall(*str,concat,1,rb_str_new2("#Ref"));
+  }else if(ERL_IS_EMPTY_LIST(ep)){
+    rb_funcall(*str,concat,1,rb_str_new2("[]"));
+  }else if(ERL_IS_LIST(ep)){
+    if (is_printable_list(ep)) {
+      fill_printable_list(str,ep);
+    } else {
+      rb_funcall(*str,concat,1,rb_str_new2("["));
+      ETERM *tl=ep,*hd,*tmp;
+      while (ERL_IS_CONS(tl)){
+        hd=erl_hd(tl);
+        fill_string(str,hd);
+        //erl_free_term(hd);
+        tmp = erl_tl(tl);
+        //if(tl!=ep)erl_free_term(tl);
+        tl=tmp;
+        if (ERL_IS_CONS(tl)) {
+          rb_funcall(*str,concat,1,rb_str_new2(", "));
+        }
+      }
+      if (!ERL_IS_EMPTY_LIST(tl)) {
+        rb_funcall(*str,concat,1,rb_str_new2("|"));
+        fill_string(str, tl);
+      }else{
+        //erl_free_term(tl);
+      }
+      rb_funcall(*str,concat,1,rb_str_new2("]"));
+    }
+  }else if(ERL_IS_TUPLE(ep)){
+    rb_funcall(*str,concat,1,rb_str_new2("{"));
+    for (i=0; i < ERL_TUPLE_SIZE(ep); i++) {
+      ETERM *e=erl_element(i+1,ep);
+      fill_string(str,e);
+      //erl_free_term(e);
+      if (i != ERL_TUPLE_SIZE(ep)-1) {
+        rb_funcall(*str,concat,1,rb_str_new2(", "));
+      }
+    }
+    rb_funcall(*str,concat,1,rb_str_new2("}"));
+  }else if(ERL_IS_BINARY(ep)){
+      rb_funcall(*str,concat,1,rb_str_new2(ERL_BIN_PTR(ep)));
+  }else if(ERL_IS_INTEGER(ep)){
+      char tmp_buf_num[24];
+      memset(tmp_buf_num,0,24);
+      sprintf(tmp_buf_num,"%d", ERL_INT_VALUE(ep));
+      rb_funcall(*str,concat,1,rb_str_new2(tmp_buf_num));
+  }else if(ERL_IS_UNSIGNED_INTEGER(ep)){
+    char tmp_buf_unum[24];
+    memset(tmp_buf_unum, 0, 24);
+    sprintf(tmp_buf_unum, "%u", ERL_INT_UVALUE(ep));
+    rb_funcall(*str,concat, 1, rb_str_new2(tmp_buf_unum));
+  }else if(ERL_IS_FLOAT(ep)){
+    char tmp_buf_float[24];
+    memset(tmp_buf_float, 0, 24);
+    sprintf(tmp_buf_float, "%f", ERL_FLOAT_VALUE(ep));
+    rb_funcall(*str,concat, 1, rb_str_new2(tmp_buf_float));
+  }else{
+    rb_funcall(*str,concat, 1, rb_str_new2("*Unknow*"));
+    //rb_raise(rb_eException,"ErlixTerm.to_s: Bad type of term !");
+  }
+}

data/src/erlix_helper.h

@@ -0,0 +1,13 @@
+#ifndef ERLIX_HELPER_H
+#define ERLIX_HELPER_H
+
+#include "ruby.h"
+#include "erl_interface.h"
+#include "ei.h"
+
+#include <ctype.h>
+#include <string.h>
+
+void fill_string(VALUE *str, ETERM *ep);
+
+#endif

data/src/intruder_ext.c

@@ -0,0 +1,48 @@
+#include "intruder_ext.h"
+
+/* common imports */
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+/* TODO in den header*/
+VALUE IntruderModule = Qnil;
+VALUE IntruderException = Qnil;
+extern VALUE IntruderNodeException;
+
+void Init_intruder_ext(){
+  erl_init(NULL, 0);
+  IntruderModule = rb_define_module("Intruder");
+  IntruderException = rb_define_class_under(IntruderModule, "Error", rb_eRuntimeError);
+
+  Init_intruder_term();
+  Init_intruder_list();
+  Init_intruder_tuple();
+  Init_intruder_atom();
+  Init_intruder_binary();
+  Init_intruder_node();
+  Init_intruder_mod();
+}
+
+void raise_rException_for_erl_errno(){
+/*     DEBUG("Result: %d\n", erl_errno); */
+/*     DEBUG("ERHOSTUNREACH: %d\n", EHOSTUNREACH); */
+/*     DEBUG("ENOMEM: %d\n", ENOMEM); */
+/*     DEBUG("EIO: %d\n", EIO); */
+
+    switch( erl_errno )
+      {
+      case EHOSTUNREACH :
+        rb_raise(IntruderNodeException, "Host unreachable");
+        break;
+      case ENOMEM :
+        rb_raise(IntruderNodeException, "Memory Error");
+        break;
+      case EIO :
+        rb_raise(IntruderNodeException, "IO error");
+        break;
+      default :
+        rb_raise(IntruderNodeException, strerror(erl_errno));
+        break;
+      }
+}

data/src/intruder_ext.h

@@ -0,0 +1,28 @@
+#ifndef INTRUDER_EXT_H_
+#define INTRUDER_EXT_H_
+
+#include "ruby.h"
+#include "node.h"
+#include "mod.h"
+#include "term.h"
+#include "list.h"
+#include "atom.h"
+#include "binary.h"
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#define RARRAY_LEN(a) (RARRAY(a)->len)
+#endif
+
+extern void raise_rException_for_erl_errno();
+#endif /* #ifndef INTRUDER_EXT_H */
+
+/*
+ * TODO: Add Check_Type checks for every method that needs a specific argument type 
+ * TODO: macros for retrival of the class structs like:
+ *       #define GetDBM(obj, dbmp) {\
+ *          Data_Get_Struct(obj, struct dbmdata, dbmp);\
+ *          if (dbmp->di_dbm == 0) closed_dbm();\
+ *       }
+*/

data/src/list.c

@@ -0,0 +1,70 @@
+#include "list.h"
+
+VALUE IntruderList = Qnil;
+
+void Init_intruder_list()
+{
+  IntruderList = rb_define_class_under(IntruderModule, "List", IntruderTerm);
+
+  rb_include_module(IntruderList, rb_mEnumerable);
+  rb_define_method(IntruderList, "each", intruder_list_each, 0);
+  rb_define_method(IntruderList, "[]", intruder_list_member_at, 1);
+  rb_define_method(IntruderList, "length", intruder_list_length, 0);
+  rb_define_alias(IntruderList, "size", "length");
+}
+
+/* lenght and size */
+VALUE intruder_list_length(VALUE self){
+  INTRUDER_TERM *term;
+  Data_Get_Struct(self, INTRUDER_TERM, term);
+
+  return INT2FIX(erl_length(term->eterm));
+}
+
+/* [] */
+VALUE intruder_list_member_at(VALUE self, VALUE pos)
+{
+  int position = NUM2INT(pos) + 1;
+  if (position <= 0 || NUM2INT(intruder_list_length(self)) < position)
+    return Qnil;
+
+  INTRUDER_TERM *term;
+  Data_Get_Struct(self, INTRUDER_TERM, term);
+
+  int i;
+  ETERM *member, *list;
+  list = erl_copy_term(term->eterm);
+
+  for(i = 1; i <= position; i++)
+    {
+      member = erl_hd(list);
+      list = erl_tl(list);
+    }
+
+  erl_free_compound(list);
+  return rb_value_from_eterm(member);
+}
+
+/* Enumerable */
+VALUE intruder_list_each(VALUE self)
+{
+  INTRUDER_TERM *term;
+  ETERM *member, *list;
+  VALUE rMember;
+  int i;
+
+  Data_Get_Struct(self, INTRUDER_TERM, term);
+  list = erl_copy_term(term->eterm);
+  int length = erl_length(list);
+
+  for(i = 1; i <= length; i++)
+    {
+      member = erl_hd(list);
+      list = erl_tl(list);
+      rMember = rb_value_from_eterm(member);
+      rb_yield(rMember);
+    }
+
+  erl_free_compound(list);
+  return Qnil;
+}

data/src/list.h

@@ -0,0 +1,19 @@
+#ifndef INTRUDER_LIST_H
+#define INTRUDER_LIST_H
+
+#include "ruby.h"
+
+#include "term.h"
+
+extern VALUE IntruderModule;
+extern VALUE IntruderTerm;
+
+void Init_intruder_list();
+
+/* Enumerable */
+VALUE intruder_list_each(VALUE self);
+
+VALUE intruder_list_member_at(VALUE self, VALUE position);
+VALUE intruder_list_length(VALUE self);
+
+#endif /* ifndef INTRUDER_LIST_H */

data/src/mod.c

@@ -0,0 +1,74 @@
+#include "mod.h"
+
+VALUE IntruderMod = Qnil;
+extern VALUE IntruderModule;
+extern VALUE IntruderTerm;
+
+VALUE intruder_mod_init(VALUE self, VALUE modname, VALUE node) {
+  rb_iv_set(self, "@node", node);
+  rb_iv_set(self, "@modname", modname);
+  return self;
+}
+
+VALUE intruder_mod_alloc(VALUE class) {
+  INTRUDER_MOD *im = (INTRUDER_MOD*)malloc(sizeof(INTRUDER_MOD));
+  VALUE obj;
+  obj = Data_Wrap_Struct(class, 0, free, im);
+  return obj;
+}
+
+VALUE intruder_mod_rpc(VALUE self, VALUE args) {
+  /* get the data struct of the Intruder::Node in the Intruder::Mod */
+  INTRUDER_NODE *inode;
+  Data_Get_Struct(rb_iv_get(self, "@node"), INTRUDER_NODE, inode);
+  if (inode->status == INTRUDER_DISCONNECTED) {
+    rb_raise(IntruderException, "node not connected");
+  }
+
+  VALUE fun = rb_ary_shift(args);
+  VALUE params = rb_ary_shift(args);
+
+  /* get the intruder term struct from the args array */
+  INTRUDER_TERM *iterm;
+  Data_Get_Struct(params, INTRUDER_TERM, iterm);
+
+  /* name of the module to call is set in a ruby ivar */
+  char *mod = RSTRING_PTR(rb_iv_get(self, "@modname"));
+  int ret;
+
+  /* prepare the erlang stuff */
+  int index = 0;
+  ei_x_buff rpcargs, result;
+  ei_x_new(&result);
+  ei_x_new(&rpcargs);
+  ei_x_encode_term(&rpcargs, iterm->eterm);
+
+/*   ei_print_term(stdout, rpcargs.buff, &index); */
+/*   fflush(stdout); */
+
+  /* RPC call */
+  pthread_mutex_lock(inode->mutex);
+  ret = ei_rpc(inode->cnode, inode->fd, mod, RSTRING_PTR(fun), rpcargs.buff, rpcargs.index, &result);
+  if (ret < 0) {
+    raise_rException_for_erl_errno();
+    return Qnil;
+  } else {
+    ETERM *tuplep;
+    tuplep = erl_decode(result.buff);
+    ei_x_free(&rpcargs);
+    ei_x_free(&result);
+    pthread_mutex_unlock(inode->mutex);
+    return rb_value_from_eterm(tuplep);
+  }
+}
+
+void Init_intruder_mod() {
+  IntruderMod = rb_define_class_under(IntruderModule, "Mod", rb_cObject);
+
+  /* class methods */
+  rb_define_alloc_func(IntruderMod, intruder_mod_alloc);
+
+  /* instance methods */
+  rb_define_method(IntruderMod, "initialize", intruder_mod_init, 2);
+  rb_define_method(IntruderMod, "rpc", intruder_mod_rpc, -2);
+}

data/src/mod.h

@@ -0,0 +1,25 @@
+#ifndef INTRUDER_MOD_H_
+#define INTRUDER_MOD_H_
+
+#include "ruby.h"
+#include "ei.h"
+#include "erl_interface.h"
+#include <stdio.h>
+#include <pthread.h>
+
+#include "intruder_ext.h"
+#include "node.h"
+#include "term.h"
+
+typedef struct intruder_mod
+{
+  ei_cnode *node;
+} INTRUDER_MOD;
+
+void Init_intruder_mod();
+
+VALUE intruder_mod_init(VALUE self, VALUE modname, VALUE node);
+VALUE intruder_mod_alloc(VALUE self);
+VALUE private_intruder_mod_rpc(VALUE self, VALUE args);
+
+#endif

data/src/node.c

@@ -0,0 +1,217 @@
+/*
+ * Helpfull stuff:
+ * Erl_interface doku: http://erlang.mirror.su.se/doc/man/ei_connect.html
+ * http://erlang.org/pipermail/erlang-questions/2003-August/009536.html
+ * Erlix discussion: http://www.mentby.com/Group/ruby-talk/ruby-interface-of-erlang.html
+ * Extending ruby (german): http://home.vrweb.de/~juergen.katins/ruby/buch/ext_ruby.html
+ * http://www.eqqon.com/index.php/Ruby_C_Extension#debug
+ */
+#include "node.h"
+
+#define STOSYM(string) ID2SYM(rb_intern(string))
+
+VALUE IntruderNode = Qnil;
+VALUE IntruderNodeException = Qnil;
+int node_count = 0;
+pthread_t alive_thread;
+pthread_mutex_t **mutexes_locked_for_keep_alive;
+INTRUDER_NODE **connectlist;
+fd_set socks;
+int highsock;
+int readsocks;
+int connectlist_inited = 0;
+unsigned int tmo = 1;
+
+/* internal methods */
+static void declare_attr_accessors();
+static void free_class_struct(void *class_struct);
+static void release_locks();
+
+void lock_node(INTRUDER_NODE *node);
+void unlock_node(INTRUDER_NODE *node);
+void read_socks();
+void *aliveloop();
+void build_select_list();
+
+/* implementation */
+VALUE intruder_node_alloc(VALUE class){
+  INTRUDER_NODE *class_struct = malloc(sizeof(INTRUDER_NODE));
+  class_struct->cnode = malloc(sizeof(ei_cnode));
+  class_struct->status = INTRUDER_DISCONNECTED;
+  class_struct->mutex = malloc(sizeof(pthread_mutex_t));
+  pthread_mutex_init(class_struct->mutex, NULL);
+
+  VALUE obj = Data_Wrap_Struct(class, 0, free_class_struct, class_struct);
+  return obj;
+}
+
+static void free_class_struct(void *class_struct)
+{
+  pthread_mutex_destroy(((INTRUDER_NODE *)class_struct)->mutex);
+  free(((INTRUDER_NODE *)class_struct)->cnode);
+  free(class_struct);
+}
+
+VALUE intruder_node_init(VALUE self, VALUE sname, VALUE cookie){
+  CLASS_STRUCT;
+
+  rb_iv_set(self, "@sname", sname);
+  rb_iv_set(self, "@cookie", cookie);
+
+  if (!connectlist_inited) {
+    connectlist = (INTRUDER_NODE **)calloc(CONBUFFSIZE, sizeof(INTRUDER_NODE*));
+    mutexes_locked_for_keep_alive = (pthread_mutex_t **)calloc(CONBUFFSIZE, sizeof(pthread_mutex_t *));
+    connectlist_inited = 1;
+  }
+
+  /* initialize the node */
+  if(ei_connect_init(class_struct->cnode, RSTRING_PTR(sname), RSTRING_PTR(cookie), node_count) < 0){
+    free(class_struct->cnode);
+    rb_raise(rb_eRuntimeError, "Error initializing the node");
+  }
+
+  return self;
+}
+
+VALUE intruder_node_status(VALUE self){
+  CLASS_STRUCT;
+  if (class_struct->status == INTRUDER_CONNECTED)
+    return STOSYM("connected");
+  else
+    return STOSYM("disconnected");
+}
+
+VALUE intruder_node_pid(VALUE self){
+  CLASS_STRUCT;
+  erlang_pid *pid = ei_self(class_struct->cnode);
+  return INT2FIX(pid->num);
+}
+
+VALUE intruder_node_connect(VALUE self, VALUE remote_node){
+  INTRUDER_NODE *class_struct;
+  Data_Get_Struct(self, INTRUDER_NODE, class_struct);
+
+  if((class_struct->fd = ei_connect_tmo(class_struct->cnode, RSTRING_PTR(remote_node), tmo)) < 0)
+    raise_rException_for_erl_errno();
+
+  class_struct->status = INTRUDER_CONNECTED;
+  connectlist[node_count] = class_struct;
+  node_count++;
+
+  if (alive_thread == NULL) {
+    pthread_create(&alive_thread, NULL, aliveloop, NULL);
+  }
+  return Qtrue;
+}
+
+void Init_intruder_node(){
+  IntruderNode = rb_define_class_under(IntruderModule, "Node", rb_cObject);
+  declare_attr_accessors();
+
+  /* class methods */
+  rb_define_alloc_func(IntruderNode, intruder_node_alloc);
+
+  /* instance methods */
+  rb_define_method(IntruderNode, "initialize", intruder_node_init, 2);
+  rb_define_method(IntruderNode, "connect", intruder_node_connect, 1);
+  rb_define_method(IntruderNode, "pid", intruder_node_pid, 0);
+  rb_define_method(IntruderNode, "status", intruder_node_status, 0);
+
+  /* exceptions */
+  IntruderNodeException = rb_define_class_under(IntruderModule, "NodeError", IntruderException);
+}
+
+static void declare_attr_accessors(){
+  ID attr_accessor = rb_intern("attr_reader");
+
+  char  *i_vars[2] = {"cookie", "sname"};
+  VALUE params[2];
+
+  int i = 0;
+  for(; i <= 1; i++){
+    params[i] = STOSYM(i_vars[i]);
+  }
+  rb_funcall2(IntruderNode, attr_accessor, 2, params);
+}
+
+void build_select_list() {
+  int listnum, locks = 0;
+  FD_ZERO(&socks);
+
+  for (listnum = 0; listnum < node_count; listnum++) {
+    if (connectlist[listnum] != NULL) {
+      if (!pthread_mutex_trylock(connectlist[listnum]->mutex)) {
+        mutexes_locked_for_keep_alive[locks++] = connectlist[listnum]->mutex;
+        FD_SET(connectlist[listnum]->fd, &socks);
+        if (connectlist[listnum]->fd > highsock)
+          highsock = connectlist[listnum]->fd;
+      }
+      else {
+/*         printf("fd %d is already locked, skipping\n", connectlist[listnum]->fd); */
+      }
+    }
+  }
+}
+
+void read_socks() {
+  int listnum;
+  int got;
+  char buf[400];
+
+  for (listnum = 0; listnum < node_count; listnum++) {
+/*     printf("checking socket %d (%d)\n", connectlist[listnum]->fd, listnum); */
+    if (connectlist[listnum] != 0 && FD_ISSET(connectlist[listnum]->fd, &socks)) {
+      got = erl_receive(connectlist[listnum]->fd, buf, 400);
+      if (got == ERL_TICK) { /* keeping the node alive */
+        continue;
+      } else {
+        rb_raise(rb_eRuntimeError, "Keep Alive thread cought a message other than ERL_TICK");
+      }
+    }
+  }
+}
+
+void *aliveloop() {
+  struct timeval timeout;
+
+  while(1) {
+    timeout.tv_sec = 1;
+    timeout.tv_usec = 0;
+
+    build_select_list();
+    /*     printf("waiting for sockets\n"); */
+    readsocks = select(highsock+1, &socks, (fd_set *) 0, (fd_set *) 0, &timeout);
+
+    if (readsocks < 0) {
+      perror("select");
+      exit(EXIT_FAILURE);
+    }
+    if (readsocks != 0)
+      read_socks();
+    release_locks(); /* TODO: maybe return the locklist from build_select_list and pass in as an argument here */
+  }
+}
+
+static void release_locks() {
+  int i;
+  pthread_mutex_t *mutex;
+/*   printf("cleaning up locks"); */
+  for (i = 0; i < CONBUFFSIZE; i++) {
+    if ((mutex = mutexes_locked_for_keep_alive[i]) != NULL) {
+/*       printf(" %d", i); */
+      pthread_mutex_unlock(mutex);
+      mutexes_locked_for_keep_alive[i] = NULL;
+    } else {
+/*       printf("\n"); */
+      break;
+    }
+  }
+}
+
+void lock_node(INTRUDER_NODE *node) {
+  pthread_mutex_lock(node->mutex);
+}
+
+void unlock_node(INTRUDER_NODE *node) {
+  pthread_mutex_unlock(node->mutex);
+}

data/src/node.h

@@ -0,0 +1,49 @@
+/* FIXME node.h =schlechte idee, umbenennen */
+#ifndef INTRUDER_NODE_H
+#define INTRUDER_NODE_H
+
+#include "ruby.h"
+#include "erl_interface.h"
+#include "ei.h"
+
+#include "intruder_ext.h"
+
+#include <stdio.h>
+
+#define INTRUDER_DEBUG
+
+#ifdef INTRUDER_DEBUG
+#define DEBUG(fmt, args...) printf(fmt, ##args)
+#else
+#define DEBUG(fmt, args...)
+#endif
+
+#define INTRUDER_CONNECTED 0
+#define INTRUDER_DISCONNECTED 1
+
+#define CONBUFFSIZE 20
+
+#define CLASS_STRUCT struct intruder_node *class_struct; Data_Get_Struct(self, struct intruder_node, class_struct)
+
+typedef struct intruder_node
+{
+  ei_cnode *cnode;
+  int fd;         /* file descriptor for the communication with the epmd */
+  int status;
+  pthread_mutex_t *mutex; /* mutex on the fd */
+} INTRUDER_NODE;
+
+extern VALUE IntruderModule;
+extern VALUE IntruderException;
+
+/* prototypes */
+void Init_intruder_node();
+
+/* ruby instance methods */
+VALUE intruder_node_init(VALUE self, VALUE sname, VALUE cookie);
+VALUE intruder_node_connect(VALUE self, VALUE remote_node);
+/* VALUE intruder_node_mod(VALUE self, VALUE mod_name); */
+
+/* ruby class methods */
+VALUE intruder_node_new(VALUE class, VALUE host, VALUE sname, VALUE cookie);
+#endif

data/src/term.c

@@ -0,0 +1,168 @@
+#include "term.h"
+
+VALUE IntruderTerm = Qnil;
+
+/* internal methods */
+void free_intruder_term(void *term) {
+  INTRUDER_TERM *iterm = term;
+  erl_free_compound(iterm->eterm);
+  free(term);
+}
+
+INTRUDER_TERM * new_intruder_term() {
+  INTRUDER_TERM *iterm = malloc(sizeof(INTRUDER_TERM));
+  return iterm;
+}
+
+/* instance methods */
+
+VALUE intruder_term_to_s(VALUE self) {
+  INTRUDER_TERM *iterm;
+  Data_Get_Struct(self, INTRUDER_TERM, iterm);
+  ETERM *eterm = iterm->eterm;
+  VALUE ret = rb_str_new2("");
+ /*  int ei_s_print_term(char** s, const char* buf, int* index) */
+/*   int index = 0; */
+/*   char *buff; */
+/*   int ei_s_print_term(&buff, , int* index); */
+  fill_string(&ret, eterm);
+  return ret;
+}
+
+VALUE rb_value_from_eterm(ETERM *eterm)
+{
+  VALUE rubyObject;
+  INTRUDER_TERM *iterm = new_intruder_term();
+  iterm->eterm = eterm;
+  if (ERL_IS_LIST(eterm))
+    rubyObject = rb_value_from_list(iterm);
+  else if (ERL_IS_TUPLE(eterm))
+    rubyObject = rb_value_from_tuple(iterm);
+  else if (ERL_IS_ATOM(eterm))
+    rubyObject = rb_value_from_atom(iterm);
+  else if (ERL_IS_BINARY(eterm))
+    rubyObject = rb_value_from_binary(iterm);
+  else
+    rubyObject = Data_Wrap_Struct(IntruderTerm, 0, free_intruder_term, iterm);
+
+  return rubyObject;
+
+  /*   figure out the type of the eterm (more to come) */
+  /*   erl_free_compound(eterm); */
+  /*   return Qnil; */
+}
+
+VALUE rb_value_from_list(INTRUDER_TERM *iterm) {
+  VALUE rValue;
+  iterm->type = INTRUDER_TYPE_LIST;
+  rValue = Data_Wrap_Struct(IntruderList, 0, free_intruder_term, iterm);
+  return rValue;
+}
+
+VALUE rb_value_from_tuple(INTRUDER_TERM *iterm) {
+  VALUE rValue;
+  iterm->type = INTRUDER_TYPE_TUPLE;
+  rValue = Data_Wrap_Struct(IntruderTuple, 0, free_intruder_term, iterm);
+  return rValue;
+}
+
+VALUE rb_value_from_atom(INTRUDER_TERM *iterm) {
+  VALUE rValue;
+  iterm->type = INTRUDER_TYPE_ATOM;
+  rValue = Data_Wrap_Struct(IntruderAtom, 0, free_intruder_term, iterm);
+  return rValue;
+}
+
+VALUE rb_value_from_binary(INTRUDER_TERM *iterm) {
+  VALUE rValue;
+  iterm->type = INTRUDER_TYPE_BINARY;
+  rValue = Data_Wrap_Struct(IntruderBinary, 0, free_intruder_term, iterm);
+  return Qnil;
+}
+
+static ETERM *intruder_eterm_from_array(VALUE obj);
+VALUE intruder_term_encode(VALUE self, VALUE obj) {
+  VALUE ret = Qnil;
+
+  ETERM *eterm = intruder_eterm_from_value(obj);
+  if (eterm == NULL) {
+    erl_free(eterm);
+    rb_raise(IntruderException, "unable to convert that ruby object to an erlang term");
+    return Qnil;
+  }
+
+  ret = rb_value_from_eterm(eterm);
+  return ret;
+}
+
+/* Create an ETERM from a Ruby VALUE
+ * currently it knows how to handle Strings, Symbols and Arrays (of strings, symbols or arrays)
+ */
+ETERM *intruder_eterm_from_value(VALUE obj) {
+  ETERM *eterm;
+  if (rb_obj_is_kind_of(obj, IntruderTerm)) {
+    INTRUDER_TERM *iterm;
+    Data_Get_Struct(obj, INTRUDER_TERM, iterm);
+    eterm = iterm->eterm;
+  } else {
+    switch(TYPE(obj)) {
+    case T_SYMBOL :
+      eterm = erl_mk_atom(rb_id2name(SYM2ID(obj)));
+      break;
+    case T_ARRAY :
+      eterm = intruder_eterm_from_array(obj);
+      break;
+    case T_STRING :
+      eterm = erl_mk_estring(RSTRING_PTR(obj), RSTRING_LEN(obj));
+      break;
+    default :
+      eterm = NULL;
+    }
+  }
+  return eterm;
+}
+
+/* creates an ETERM from a ruby array of symbols, strings or arrays again */
+static ETERM *intruder_eterm_from_array(VALUE obj) {
+  int size = RARRAY_LEN(obj);
+
+  if (size == 0)
+    return erl_format("[]");
+
+  ETERM **list = (ETERM **)malloc(sizeof(ETERM*) * size);
+  ETERM *element, *eterm;
+  INTRUDER_TERM *iterm;
+  VALUE rElement;
+  int i;
+
+  for (i = 0; i < size; i++) {
+    rElement = rb_ary_shift(obj);
+    element = intruder_eterm_from_value(rElement);
+    if (element == NULL) { /* it could not be decoded */
+      free(list);
+      return NULL;
+    }
+    *(list+i) = element;
+  }
+
+  eterm = erl_mk_list(list, size);
+  free(list);
+  return eterm;
+}
+
+VALUE intruder_term_alloc(VALUE class) {
+  INTRUDER_TERM *iterm = new_intruder_term();
+  VALUE obj = Data_Wrap_Struct(class, 0, free_intruder_term, iterm);
+  return obj;
+}
+
+void Init_intruder_term(){
+  IntruderTerm = rb_define_class_under(IntruderModule, "Term", rb_cObject);
+
+  /* instance methods */
+  rb_define_method(IntruderTerm, "to_s", intruder_term_to_s, 0);
+  rb_define_singleton_method(IntruderTerm, "encode", intruder_term_encode, 1);
+
+  /* allocation */
+  rb_define_alloc_func(IntruderTerm, intruder_term_alloc);
+}

data/src/term.h

@@ -0,0 +1,58 @@
+#ifndef INTRUDER_TERM_H
+#define INTRUDER_TERM_H
+
+#include "ruby.h"
+#include "ei.h"
+#include "erl_interface.h"
+
+#include "intruder_ext.h"
+#include "list.h"
+#include "erlix_helper.h"
+
+#define INTRUDER_TYPE_ATOM       0
+#define INTRUDER_TYPE_LIST       1
+#define INTRUDER_TYPE_TUPLE      2
+#define INTRUDER_TYPE_INT        3
+#define INTRUDER_TYPE_UINT       4
+#define INTRUDER_TYPE_FLOAT      5
+#define INTRUDER_TYPE_PID        6
+#define INTRUDER_TYPE_PORT       7
+#define INTRUDER_TYPE_REF        8
+#define INTRUDER_TYPE_BIN        9
+#define INTRUDER_TYPE_CON       10
+#define INTRUDER_TYPE_STRING    11
+#define INTRUDER_TYPE_BINARY    12
+
+extern VALUE IntruderModule;
+extern VALUE IntruderList;
+extern VALUE IntruderTuple;
+extern VALUE IntruderAtom;
+extern VALUE IntruderException;
+extern VALUE IntruderBinary;
+
+typedef struct intruder_term
+{
+  ETERM *eterm;
+  int type;
+} INTRUDER_TERM;
+
+void Init_intruder_term();
+
+/* instance methods */
+VALUE intruder_term_to_s(VALUE self);
+VALUE intruder_term_encode(VALUE self, VALUE ruby_object);
+
+  /* allocation */
+VALUE intruder_term_alloc(VALUE class);
+void free_intruder_term(void *term);
+INTRUDER_TERM *new_intruder_term();
+
+/* C Methods */
+VALUE rb_value_from_eterm(ETERM *eterm);
+VALUE rb_value_from_list(INTRUDER_TERM *iterm);
+VALUE rb_value_from_tuple(INTRUDER_TERM *iterm);
+VALUE rb_value_from_atom(INTRUDER_TERM *iterm);
+VALUE rb_value_from_binary(INTRUDER_TERM *iterm);
+ETERM *intruder_eterm_from_value(VALUE obj);
+
+#endif /* ifndef INTRUDER_TERM_H */

data/src/tuple.c

@@ -0,0 +1,55 @@
+#include "tuple.h"
+
+VALUE IntruderTuple = Qnil;
+
+void Init_intruder_tuple() {
+  IntruderTuple = rb_define_class_under(IntruderModule, "Tuple", IntruderTerm);
+
+  rb_include_module(IntruderTuple, rb_mEnumerable);
+  rb_define_method(IntruderTuple, "initialize", intruder_tuple_init, 1);
+  rb_define_method(IntruderTuple, "each", intruder_tuple_each, 0);
+  rb_define_method(IntruderTuple, "[]", intruder_tuple_member_at, 1);
+  rb_define_method(IntruderTuple, "length", intruder_tuple_length, 0);
+  rb_define_alias(IntruderTuple, "size", "length");
+}
+
+VALUE intruder_tuple_each(VALUE self) {
+  INTRUDER_TERM *iterm;
+  Data_Get_Struct(self, INTRUDER_TERM, iterm);
+  int i;
+  for (i = 1; i <= erl_size(iterm->eterm); i++) {
+    rb_yield(rb_value_from_eterm(erl_element(i, iterm-> eterm)));
+  }
+  return Qnil;
+}
+
+VALUE intruder_tuple_init(VALUE self, VALUE arr) {
+  int i, arrsize = RARRAY_LEN(arr);
+  INTRUDER_TERM *iterm;
+  ETERM **members = (ETERM**)malloc(sizeof(ETERM*) * arrsize);
+
+  for (i = 0; i < arrsize; i++) {
+    members[i] = intruder_eterm_from_value(rb_ary_shift(arr));
+  }
+
+  Data_Get_Struct(self, INTRUDER_TERM, iterm);
+  iterm->eterm = erl_mk_tuple(members, arrsize);
+  return self;
+}
+
+VALUE intruder_tuple_member_at(VALUE self, VALUE position) {
+  INTRUDER_TERM *iterm;
+  ETERM *member;
+  int iPosition = NUM2INT(position);
+  Data_Get_Struct(self, INTRUDER_TERM, iterm);
+  member = erl_element(iPosition+1, iterm->eterm);
+  return rb_value_from_eterm(member);
+}
+
+VALUE intruder_tuple_length(VALUE self) {
+  INTRUDER_TERM *iterm;
+  Data_Get_Struct(self, INTRUDER_TERM, iterm);
+  int iLength;
+  iLength = erl_size(iterm->eterm);
+  return INT2NUM(iLength);
+}

data/src/tuple.h

@@ -0,0 +1,17 @@
+#ifndef INTRUDER_TUPLE_H
+#define INTRUDER_TUPLE_H
+
+#include "ruby.h"
+#include "term.h"
+
+extern VALUE IntruderModule;
+extern VALUE IntruderTerm;
+
+void Init_intruder_tuple();
+
+VALUE intruder_tuple_each(VALUE self);
+VALUE intruder_tuple_init(VALUE self, VALUE arr);
+VALUE intruder_tuple_member_at(VALUE self, VALUE position);
+VALUE intruder_tuple_length(VALUE self);
+
+#endif /* ifndef INTRUDER_TUPLE_H */

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Pascal Friederich
@@ -14,20 +14,53 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-11 00:00:00 +01:00
+date: 2010-03-11 00:00:00 +00:00
 default_executable: 
-dependencies: []
-
-description: ===========
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 0
+        version: 1.5.0
+  type: :development
+  version_requirements: *id001
+description: Communicate with erlang from within ruby natively
 email: paukul@gmail.com
 executables: []
 
-extensions: []
-
+extensions: 
+- extconf.rb
 extra_rdoc_files: 
 - README.md
-files: []
-
+files: 
+- README.md
+- findei.erl
+- src/atom.c
+- src/atom.h
+- src/binary.c
+- src/binary.h
+- src/erlix_helper.c
+- src/erlix_helper.h
+- src/intruder_ext.c
+- src/intruder_ext.h
+- src/list.c
+- src/list.h
+- src/mod.c
+- src/mod.h
+- src/node.c
+- src/node.h
+- src/term.c
+- src/term.h
+- src/tuple.c
+- src/tuple.h
+- lib/intruder.rb
 has_rdoc: true
 homepage: http://github.com/paukul/intruder
 licenses: []