ffi 0.1.1 → 0.2.0

data/Rakefile

@@ -1,16 +1,19 @@
 require 'rubygems'
 require 'rake/gempackagetask'
 require 'rubygems/specification'
-require "spec/rake/spectask"
 require 'date'
 require 'fileutils'
+require 'rbconfig'
 
 GEM = "ffi"
-GEM_VERSION = "0.1.1"
+GEM_VERSION = "0.2.0"
 AUTHOR = "Wayne Meissner"
 EMAIL = "wmeissner@gmail.com"
 HOMEPAGE = "http://kenai.com/projects/ruby-ffi"
 SUMMARY = "A Ruby foreign function interface (compatible with Rubinius and JRuby FFI)"
+LIBEXT = Config::CONFIG['host_os'].downcase =~ /darwin/ ? "dylib" : "so"
+GMAKE = Config::CONFIG['host_os'].downcase =~ /bsd/ ? "gmake" : "make"
+LIBTEST = "build/libtest.#{LIBEXT}"
 
 spec = Gem::Specification.new do |s|
   s.name = GEM
@@ -24,41 +27,33 @@ spec = Gem::Specification.new do |s|
   s.email = EMAIL
   s.homepage = HOMEPAGE
   s.rubyforge_project = 'ffi' 
-  s.extensions = %w(ext/extconf.rb)
+  s.extensions = %w(ext/extconf.rb gen/Rakefile)
   
   s.require_path = 'lib'
   s.autorequire = GEM
   s.files = %w(LICENSE README Rakefile) + Dir.glob("{ext,lib,nbproject,samples,specs}/**/*")
 end
-
-desc "Run all specs"
-Spec::Rake::SpecTask.new("specs") do |t|
-  t.spec_opts = ["--format", "specdoc", "--colour"]
-  t.spec_files = Dir["spec/**/*_spec.rb"].sort
-end
-desc "Run rubinius specs"
-Spec::Rake::SpecTask.new("rbxspecs") do |t|
-  t.spec_opts = ["--format", "specdoc", "--colour"]
-  t.spec_files = Dir["spec/rbx/*_spec.rb"].sort
-end
-
+TEST_DEPS = [ LIBTEST ]
 if RUBY_PLATFORM == "java"
-  desc "Run specs"
-  task :specs do
+  desc "Run all specs"
+  task :specs => TEST_DEPS do
     sh %{#{Gem.ruby} -S spec #{Dir["specs/**/*_spec.rb"].join(" ")} -fs --color}
   end
-  task :rbxspecs do
+  desc "Run rubinius specs"
+  task :rbxspecs => TEST_DEPS do
     sh %{#{Gem.ruby} -S spec #{Dir["specs/rbx/**/*_spec.rb"].join(" ")} -fs --color}
   end
 else
-  desc "Run specs"
-  task :specs do
+  TEST_DEPS.unshift :compile
+  desc "Run all specs"
+  task :specs => TEST_DEPS do
     ENV["MRI_FFI"] = "1"
-    sh %{#{Gem.ruby} -S spec #{Dir["specs/**/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -Ibuild -Ilib -S spec #{Dir["specs/**/*_spec.rb"].join(" ")} -fs --color}
   end
-  task :rbxspecs do
+  desc "Run rubinius specs"
+  task :rbxspecs => TEST_DEPS do
     ENV["MRI_FFI"] = "1"
-    sh %{#{Gem.ruby} -S spec #{Dir["specs/rbx/**/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -Ibuild -Ilib -S spec #{Dir["specs/rbx/**/*_spec.rb"].join(" ")} -fs --color}
   end
 end
 
@@ -77,14 +72,42 @@ task :make_spec do
     file.puts spec.to_ruby
   end
 end
-file "Makefile" do
-  sh %{#{Gem.ruby} ext/extconf.rb}
+file "build/Makefile" do
+  FileUtils.mkdir_p("build") unless File.directory?("build")
+  sh %{cd build && #{Gem.ruby} ../ext/extconf.rb}
 end
-task :compile => "Makefile" do
-  sh %{make}
+desc "Compile the native module"
+task :compile => "build/Makefile" do
+  sh %{cd build; make}
 end
+desc "Clean all built files"
 task :clean do
-  sh %{make clean} if File.exists?("Makefile")
+  sh %{cd build;make distclean} if File.exists?("build/Makefile")
   FileUtils.rm_rf("build")
-  FileUtils.rm_f(Dir["pkg/*.gem", "Makefile"])
+  FileUtils.rm_rf("conftest.dSYM")
+  FileUtils.rm_f(Dir["pkg/*.gem"])
+  FileUtils.rm_f("Makefile")
 end
+task "build/libtest.#{LIBEXT}" do
+  sh %{#{GMAKE} -f libtest/GNUmakefile}
+end
+
+desc "Test the extension"
+task :test => [ :specs, :rbxspecs ] do
+
+end
+namespace :bench do
+  ITER = ENV['ITER'] ? ENV['ITER'].to_i : 100000
+  bench_libs = "-Ibuild -Ilib" unless RUBY_PLATFORM == "java"
+  bench_files = Dir["bench/bench_*.rb"].reject { |f| f == "bench_helper.rb" }
+  bench_files.each do |bench|
+    task File.basename(bench, ".rb")[6..-1] => TEST_DEPS do
+      sh %{#{Gem.ruby} #{bench_libs} #{bench} #{ITER}}
+    end
+  end
+  task :all => TEST_DEPS do
+    bench_files.each do |bench|
+      sh %{#{Gem.ruby} #{bench_libs} #{bench}}
+    end
+  end
+end

data/ext/AbstractMemory.c

@@ -4,8 +4,9 @@
 #include <stdbool.h>
 #include <ruby.h>
 #include "rbffi.h"
+#include "compat.h"
 #include "AbstractMemory.h"
-#include "MemoryPointer.h"
+#include "Pointer.h"
 
 static VALUE memory_put_float32(VALUE self, VALUE offset, VALUE value);
 static VALUE memory_get_float32(VALUE self, VALUE offset);
@@ -17,6 +18,7 @@ static VALUE memory_get_pointer(VALUE self, VALUE offset);
 static inline caddr_t memory_address(VALUE self);
 VALUE rb_FFI_AbstractMemory_class = Qnil;
 static VALUE classMemory = Qnil;
+static ID to_ptr = 0;
 
 #define ADDRESS(self, offset) (memory_address((self)) + NUM2ULONG(offset))
 #ifndef RARRAY_LEN
@@ -98,19 +100,29 @@ memory_put_pointer(VALUE self, VALUE offset, VALUE value)
 { 
     AbstractMemory* memory = (AbstractMemory *) DATA_PTR(self);
     long off = NUM2LONG(offset);
+    const int type = TYPE(value);
     checkBounds(memory, off, sizeof(void *));
-    if (rb_obj_is_kind_of(value, rb_FFI_MemoryPointer_class)) {        
+
+    if (rb_obj_is_kind_of(value, rb_FFI_Pointer_class) && type == T_DATA) {
         void* tmp = memory_address(value);
         memcpy(memory->address + off, &tmp, sizeof(tmp));
-    } else if (TYPE(value) == T_NIL) {
+    } else if (type == T_NIL) {
         void* tmp = NULL;
         memcpy(memory->address + off, &tmp, sizeof(tmp));
-    } else if (TYPE(value) == T_FIXNUM) {
+    } else if (type == T_FIXNUM) {
         uintptr_t tmp = (uintptr_t) FIX2INT(value);
         memcpy(memory->address + off, &tmp, sizeof(tmp));
-    } else if (TYPE(value) == T_BIGNUM) {
+    } else if (type == T_BIGNUM) {
         uintptr_t tmp = (uintptr_t) NUM2ULL(value);
         memcpy(memory->address + off, &tmp, sizeof(tmp));
+    } else if (rb_respond_to(value, to_ptr)) {
+        VALUE ptr = rb_funcall2(value, to_ptr, 0, NULL);
+        if (rb_obj_is_kind_of(ptr, rb_FFI_Pointer_class) && TYPE(ptr) == T_DATA) {
+            void* tmp = memory_address(ptr);
+            memcpy(memory->address + off, &tmp, sizeof(tmp));
+        } else {
+            rb_raise(rb_eArgError, "to_ptr returned an invalid pointer");
+        }
     } else {
         rb_raise(rb_eArgError, "value is not a pointer");
     }
@@ -125,7 +137,7 @@ memory_get_pointer(VALUE self, VALUE offset)
     caddr_t tmp;
     checkBounds(memory, off, sizeof(tmp));
     memcpy(&tmp, memory->address + off, sizeof(tmp));
-    return rb_FFI_MemoryPointer_new(tmp);
+    return rb_FFI_Pointer_new(tmp);
 }
 
 static VALUE
@@ -148,44 +160,71 @@ memory_get_string(int argc, VALUE* argv, VALUE self)
     VALUE length = Qnil, offset = Qnil;
     AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
     long off, len;
+    caddr_t end;
     int nargs = rb_scan_args(argc, argv, "11", &offset, &length);
 
-    off = NUM2LONG(offset);    
-    if (nargs > 1) {
-        len = NUM2LONG(length);
-    } else {        
-        caddr_t end;
-        checkBounds(ptr, off, 1);
-        end = memchr(ptr->address + off, 0, ptr->size - off);
-        len = ((end != NULL) ? end - ptr->address: ptr->size) - off;
-    }
+    off = NUM2LONG(offset);
+    len = nargs > 1 && length != Qnil ? NUM2LONG(length) : (ptr->size - off);
     checkBounds(ptr, off, len);
-    return rb_str_new((char *) ptr->address + off, len);
+    end = memchr(ptr->address + off, 0, len);
+    return rb_tainted_str_new((char *) ptr->address + off,
+            (end != NULL ? end - ptr->address - off : len));
 }
 
 static VALUE
-memory_put_string(int argc, VALUE* argv, VALUE self)
+memory_put_string(VALUE self, VALUE offset, VALUE str)
 {
     AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
-    VALUE offset = Qnil, str = Qnil, length = Qnil;
-    bool nulTerminate = true;
     long off, len;
-    int nargs = rb_scan_args(argc, argv, "21", &offset, &str, &length);
+
     off = NUM2LONG(offset);
     len = RSTRING_LEN(str);
-    if (nargs > 2 && length != Qnil) {
-        len = MIN(NUM2ULONG(length), len);
-        nulTerminate = false;
-    }
     checkBounds(ptr, off, len);
+    if (rb_safe_level() >= 1 && OBJ_TAINTED(str)) {
+        rb_raise(rb_eSecurityError, "Writing unsafe string to memory");
+    }
     memcpy(ptr->address + off, RSTRING_PTR(str), len);
+    *((char *) ptr->address + off + len) = '\0';
+    return self;
+}
+
+static VALUE
+memory_get_bytes(VALUE self, VALUE offset, VALUE length)
+{
+    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    long off, len;
+    
+    off = NUM2LONG(offset);
+    len = NUM2LONG(length);
+    checkBounds(ptr, off, len);
+    return rb_tainted_str_new((char *) ptr->address + off, len);
+}
+
+static VALUE
+memory_put_bytes(int argc, VALUE* argv, VALUE self)
+{
+    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    VALUE offset = Qnil, str = Qnil, rbIndex = Qnil, rbLength = Qnil;
+    long off, len, idx;
+    int nargs = rb_scan_args(argc, argv, "22", &offset, &str, &rbIndex, &rbLength);
 
-    if (nulTerminate) {
-        char nul = '\0';
-        memcpy(ptr->address + off + len, &nul, sizeof(nul));
+    off = NUM2LONG(offset);
+    idx = nargs > 2 ? NUM2LONG(rbIndex) : 0;
+    if (idx < 0) {
+        rb_raise(rb_eRangeError, "index canot be less than zero");
+    }
+    len = nargs > 3 ? NUM2LONG(rbLength) : (RSTRING_LEN(str) - idx);
+    if ((idx + len) > RSTRING_LEN(str)) {
+        rb_raise(rb_eRangeError, "index+length is greater than size of string");
+    }
+    checkBounds(ptr, off, len);
+    if (rb_safe_level() >= 1 && OBJ_TAINTED(str)) {
+        rb_raise(rb_eSecurityError, "Writing unsafe string to memory");
     }
+    memcpy(ptr->address + off, RSTRING_PTR(str) + idx, len);
     return self;
 }
+
 static inline caddr_t
 memory_address(VALUE self)
 {
@@ -250,8 +289,13 @@ rb_FFI_AbstractMemory_Init()
     rb_define_method(classMemory, "put_pointer", memory_put_pointer, 2);
     rb_define_method(classMemory, "get_pointer", memory_get_pointer, 1);
     rb_define_method(classMemory, "get_string", memory_get_string, -1);
-    rb_define_method(classMemory, "put_string", memory_put_string, -1);
+    rb_define_method(classMemory, "put_string", memory_put_string, 2);
+    rb_define_method(classMemory, "get_bytes", memory_get_bytes, 2);
+    rb_define_method(classMemory, "put_bytes", memory_put_bytes, -1);
+
     rb_define_method(classMemory, "clear", memory_clear, 0);
     rb_define_method(classMemory, "total", memory_size, 0);
+
+    to_ptr = rb_intern("to_ptr");
 }
 

data/ext/AutoPointer.c

@@ -0,0 +1,54 @@
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+#include "Pointer.h"
+#include "AutoPointer.h"
+
+typedef struct AutoPointer {
+    AbstractMemory memory;
+    VALUE parent;
+} AutoPointer;
+
+VALUE rb_FFI_AutoPointer_class;
+static VALUE classAutoPointer = Qnil;
+static void autoptr_mark(AutoPointer* ptr);
+static void autoptr_free(AutoPointer* ptr);
+
+static VALUE
+autoptr_new(VALUE klass, VALUE other)
+{
+    AutoPointer* p;
+    AbstractMemory* ptr;
+    VALUE retval;
+
+    retval = Data_Make_Struct(klass, AutoPointer, autoptr_mark, autoptr_free, p);
+    ptr = (AbstractMemory *) DATA_PTR(other);
+    p->memory = *ptr;
+    p->parent = other;
+    return retval;
+}
+
+static void
+autoptr_mark(AutoPointer* ptr)
+{
+    if (ptr->parent != Qnil) {
+        rb_gc_mark(ptr->parent);
+    }
+}
+static void
+autoptr_free(AutoPointer* ptr)
+{
+    xfree(ptr);
+}
+
+void
+rb_FFI_AutoPointer_Init()
+{
+    VALUE moduleFFI = rb_define_module("FFI");
+    rb_FFI_AutoPointer_class = classAutoPointer = rb_define_class_under(moduleFFI, "AutoPointer", rb_FFI_Pointer_class);
+    rb_define_singleton_method(classAutoPointer, "__alloc", autoptr_new, 1);
+}

data/ext/AutoPointer.h

@@ -0,0 +1,18 @@
+
+#ifndef _AUTOPOINTER_H
+#define	_AUTOPOINTER_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+extern void rb_FFI_AutoPointer_Init(void);
+extern VALUE rb_FFI_AutoPointer_class;
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _AUTOPOINTER_H */
+

data/ext/Buffer.c

@@ -7,6 +7,7 @@
 
 typedef struct Buffer {
     AbstractMemory memory;
+    caddr_t address; /* The C heap address */
     VALUE parent;
 } Buffer;
 
@@ -20,22 +21,24 @@ static VALUE
 buffer_allocate(VALUE self, VALUE size, VALUE count, VALUE clear)
 {
     Buffer* p;
+    VALUE retval;
+    unsigned long msize = NUM2LONG(size) * (count == Qnil ? 1 : NUM2LONG(count));
+    caddr_t memory;
 
-    p = ALLOC(Buffer);
-    memset(p, 0, sizeof(*p));
-    p->memory.size = NUM2LONG(size) * (count == Qnil ? 1 : NUM2LONG(count));
-    p->memory.address = p->memory.size > 0 ? malloc(p->memory.size) : NULL;
-    p->parent = Qnil;
-
-    if (p->memory.address == NULL) {
-        int size = p->memory.size;
-        xfree(p);
-        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%u bytes", size);
+    memory = malloc(msize + 7);
+    if (memory == NULL) {
+        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%lu bytes", msize);
     }
-    if (TYPE(clear) == T_TRUE) {
+    retval = Data_Make_Struct(classBuffer, Buffer, buffer_mark, buffer_release, p);
+    p->address = memory;
+    p->memory.size = msize;
+    /* ensure the memory is aligned on at least a 8 byte boundary */
+    p->memory.address = (caddr_t) (((uintptr_t) memory + 0x7) & (uintptr_t) ~0x7UL);;
+    p->parent = Qnil;
+    if (TYPE(clear) == T_TRUE && p->memory.size > 0) {
         memset(p->memory.address, 0, p->memory.size);
     }
-    return Data_Wrap_Struct(classBuffer, buffer_mark, buffer_release, p);
+    return retval;
 }
 
 static VALUE
@@ -43,15 +46,15 @@ buffer_plus(VALUE self, VALUE offset)
 {
     Buffer* ptr = (Buffer *) DATA_PTR(self);
     Buffer* p;
+    VALUE retval;
     long off = NUM2LONG(offset);
 
     checkBounds(&ptr->memory, off, 1);
-    p = ALLOC(Buffer);
-    memset(p, 0, sizeof(*p));
+    retval = Data_Make_Struct(classBuffer, Buffer, buffer_mark, buffer_release, p);
     p->memory.address = ptr->memory.address + off;;
     p->memory.size = ptr->memory.size - off;
     p->parent = self;
-    return Data_Wrap_Struct(classBuffer, buffer_mark, buffer_release, p);
+    return retval;
 }
 
 static VALUE
@@ -66,8 +69,9 @@ buffer_inspect(VALUE self)
 static void
 buffer_release(Buffer* ptr)
 {
-    if (ptr->parent != Qnil && ptr->memory.address != NULL) {
-        free(ptr->memory.address);
+    if (ptr->parent == Qnil && ptr->address != NULL) {
+        free(ptr->address);
+        ptr->address = NULL;
     }
     xfree(ptr);
 

data/ext/Callback.c

@@ -1,50 +1,58 @@
+#include <sys/param.h>
 #include <sys/types.h>
+#include <sys/mman.h>
 #include <ruby.h>
-#include "MemoryPointer.h"
+#include <ffi.h>
 #include "AbstractMemory.h"
+#include "Pointer.h"
+#include "MemoryPointer.h"
 #include "Callback.h"
 #include "Types.h"
 #include "rbffi.h"
+#include "compat.h"
+#include "extconf.h"
 
 
+static void CallbackInfo_mark(CallbackInfo *);
+static void CallbackInfo_free(CallbackInfo *);
 
-static void callback_mark(CallbackInfo *);
-static void callback_free(CallbackInfo *);
+#if defined(HAVE_LIBFFI) && !defined(HAVE_FFI_CLOSURE_ALLOC)
+static void* ffi_closure_alloc(size_t size, void** code);
+static void ffi_closure_free(void* ptr);
+ffi_status ffi_prep_closure_loc(ffi_closure* closure, ffi_cif* cif,
+        void (*fun)(ffi_cif*, void*, void**, void*),
+        void* user_data, void* code);
+#endif /* HAVE_FFI_CLOSURE_ALLOC */
 
-static VALUE classCallback = Qnil;
+static VALUE classCallbackInfo = Qnil;
 static VALUE classNativeCallback = Qnil;
 static ID callID = Qnil;
 
-//static VALUE classCallbackImpl = Qnil;
-VALUE rb_FFI_Callback_class = Qnil;
+VALUE rb_FFI_CallbackInfo_class = Qnil;
 
 static VALUE
-callback_new(VALUE self, VALUE rbReturnType, VALUE rbParamTypes)
+CallbackInfo_new(VALUE klass, VALUE rbReturnType, VALUE rbParamTypes)
 {
-    CallbackInfo *cbInfo = ALLOC(CallbackInfo);
+    CallbackInfo *cbInfo;
+    VALUE retval;
     int paramCount = RARRAY_LEN(rbParamTypes);
     ffi_status status;
     int i;
 
+    retval = Data_Make_Struct(klass, CallbackInfo, CallbackInfo_mark, CallbackInfo_free, cbInfo);
     cbInfo->parameterCount = paramCount;
-    cbInfo->parameterTypes = calloc(paramCount, sizeof(NativeType));
-    cbInfo->ffiParameterTypes = calloc(paramCount, sizeof(ffi_type *));
-    if (cbInfo->parameterTypes == NULL || cbInfo->ffiParameterTypes == NULL) {
-        callback_free(cbInfo);
-        rb_raise(rb_eNoMemError, "Failed to allocate native memory");
-    }
+    cbInfo->parameterTypes = xcalloc(paramCount, sizeof(NativeType));
+    cbInfo->ffiParameterTypes = xcalloc(paramCount, sizeof(ffi_type *));
     for (i = 0; i < paramCount; ++i) {
         cbInfo->parameterTypes[i] = FIX2INT(rb_ary_entry(rbParamTypes, i));
         cbInfo->ffiParameterTypes[i] = rb_FFI_NativeTypeToFFI(cbInfo->parameterTypes[i]);
         if (cbInfo->ffiParameterTypes[i] == NULL) {
-            callback_free(cbInfo);
             rb_raise(rb_eArgError, "Unknown argument type: %#x", cbInfo->parameterTypes[i]);
         }
     }
     cbInfo->returnType = FIX2INT(rbReturnType);
     cbInfo->ffiReturnType = rb_FFI_NativeTypeToFFI(cbInfo->returnType);
     if (cbInfo->ffiReturnType == NULL) {
-        callback_free(cbInfo);
         rb_raise(rb_eArgError, "Unknown return type: %#x", cbInfo->returnType);
     }
 #ifdef _WIN32
@@ -56,34 +64,33 @@ callback_new(VALUE self, VALUE rbReturnType, VALUE rbParamTypes)
             cbInfo->ffiReturnType, cbInfo->ffiParameterTypes);
     switch (status) {
         case FFI_BAD_ABI:
-            callback_free(cbInfo);
             rb_raise(rb_eArgError, "Invalid ABI specified");
         case FFI_BAD_TYPEDEF:
-            callback_free(cbInfo);
             rb_raise(rb_eArgError, "Invalid argument type specified");
         case FFI_OK:
             break;
         default:
-            callback_free(cbInfo);
             rb_raise(rb_eArgError, "Unknown FFI error");
     }
-    return Data_Wrap_Struct(classCallback, callback_mark, callback_free, cbInfo);
+    return retval;
 }
 
 static void
-callback_mark(CallbackInfo* cbinfo)
+CallbackInfo_mark(CallbackInfo* cbinfo)
 {
 }
 
 static void
-callback_free(CallbackInfo* cbInfo)
+CallbackInfo_free(CallbackInfo* cbInfo)
 {
     if (cbInfo != NULL) {
         if (cbInfo->parameterTypes != NULL) {
-            free(cbInfo->parameterTypes);
+            xfree(cbInfo->parameterTypes);
+            cbInfo->parameterTypes = NULL;
         }
         if (cbInfo->ffiParameterTypes != NULL) {
-            free(cbInfo->ffiParameterTypes);
+            xfree(cbInfo->ffiParameterTypes);
+            cbInfo->ffiParameterTypes = NULL;
         }
         xfree(cbInfo);
     }
@@ -120,19 +127,19 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
         VALUE param;
         switch (cbInfo->parameterTypes[i]) {
             case INT8:
-                param = INT2FIX(*(int8_t *) parameters[i]);
+                param = INT2NUM(*(int8_t *) parameters[i]);
                 break;
             case UINT8:
                 param = UINT2NUM(*(u_int8_t *) parameters[i]);
                 break;
             case INT16:
-                param = INT2FIX(*(int16_t *) parameters[i]);
+                param = INT2NUM(*(int16_t *) parameters[i]);
                 break;
             case UINT16:
                 param = UINT2NUM(*(u_int16_t *) parameters[i]);
                 break;
             case INT32:
-                param = INT2FIX(*(int32_t *) parameters[i]);
+                param = INT2NUM(*(int32_t *) parameters[i]);
                 break;
             case UINT32:
                 param = UINT2NUM(*(u_int32_t *) parameters[i]);
@@ -150,10 +157,10 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
                 param = rb_float_new(*(double *) parameters[i]);
                 break;
             case STRING:
-                param = rb_str_new2(*(char **) parameters[i]);
+                param = rb_tainted_str_new2(*(char **) parameters[i]);
                 break;
             case POINTER:
-                param = rb_FFI_MemoryPointer_new(*(caddr_t *) parameters[i]);
+                param = rb_FFI_Pointer_new(*(caddr_t *) parameters[i]);
                 break;
             default:
                 param = Qnil;
@@ -166,22 +173,14 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
         memset(retval, 0, cbInfo->ffiReturnType->size);
     } else switch (cbInfo->returnType) {
         case INT8:
-            *((int8_t *) retval) = NUM2INT(rbReturnValue);
-            break;
-        case UINT8:
-            *((u_int8_t *) retval) = NUM2UINT(rbReturnValue);
-            break;
         case INT16:
-            *((int16_t *) retval) = NUM2INT(rbReturnValue);
-            break;
-        case UINT16:
-            *((u_int16_t *) retval) = NUM2UINT(rbReturnValue);
-            break;
         case INT32:
-            *((int32_t *) retval) = NUM2INT(rbReturnValue);
+            *((long *) retval) = NUM2INT(rbReturnValue);
             break;
+        case UINT8:
+        case UINT16:
         case UINT32:
-            *((u_int32_t *) retval) = NUM2UINT(rbReturnValue);
+            *((unsigned long *) retval) = NUM2UINT(rbReturnValue);
             break;
         case INT64:
             *((int64_t *) retval) = NUM2LL(rbReturnValue);
@@ -229,12 +228,51 @@ rb_FFI_NativeCallback_new(VALUE rbCallbackInfo, VALUE rbProc)
     return Data_Wrap_Struct(classNativeCallback, native_callback_mark, native_callback_free, closure);
 }
 
+#if defined(HAVE_LIBFFI) && !defined(HAVE_FFI_CLOSURE_ALLOC)
+/*
+ * versions of ffi_closure_alloc, ffi_closure_free and ffi_prep_closure_loc for older
+ * system libffi versions.
+ */
+static void*
+ffi_closure_alloc(size_t size, void** code)
+{
+    void* closure;
+    closure = mmap(NULL, size, PROT_READ | PROT_WRITE,
+             MAP_ANON | MAP_PRIVATE, -1, 0);
+    if (closure == (void *) -1) {
+        return NULL;
+    }
+    memset(closure, 0, size);
+    *code = closure;
+    return closure;
+}
+
+static void
+ffi_closure_free(void* ptr)
+{
+    munmap(ptr, sizeof(ffi_closure));
+}
+
+ffi_status
+ffi_prep_closure_loc(ffi_closure* closure, ffi_cif* cif,
+        void (*fun)(ffi_cif*, void*, void**, void*),
+        void* user_data, void* code)
+{
+    ffi_status retval = ffi_prep_closure(closure, cif, fun, user_data);
+    if (retval == FFI_OK) {
+        mprotect(closure, sizeof(ffi_closure), PROT_READ | PROT_EXEC);
+    }
+    return retval;
+}
+
+#endif /* HAVE_FFI_CLOSURE_ALLOC */
+
 void
 rb_FFI_Callback_Init()
 {
     VALUE moduleFFI = rb_define_module("FFI");
-    rb_FFI_Callback_class = classCallback = rb_define_class_under(moduleFFI, "Callback", rb_cObject);
-    rb_define_singleton_method(classCallback, "new", callback_new, 2);
+    rb_FFI_CallbackInfo_class = classCallbackInfo = rb_define_class_under(moduleFFI, "CallbackInfo", rb_cObject);
+    rb_define_singleton_method(classCallbackInfo, "new", CallbackInfo_new, 2);
     classNativeCallback = rb_define_class_under(moduleFFI, "NativeCallback", rb_cObject);
     callID = rb_intern("call");
 }