ffi 1.1.5 → 1.15.5

data/ext/ffi_c/Call.c

@@ -3,21 +3,30 @@
  * Copyright (c) 2009, Luc Heinrich <luc@honk-honk.com>
  * Copyright (c) 2009, Mike Dalessio <mike.dalessio@gmail.com>
  * Copyright (c) 2009, Aman Gupta.
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
  * All rights reserved.
  *
- * This file is part of ruby-ffi.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the Ruby FFI project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
  *
- * This code is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
- * version 3 for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef _MSC_VER
@@ -25,17 +34,12 @@
 #endif
 #include <sys/types.h>
 #include <stdio.h>
-#ifndef _MSC_VER
 #include <stdint.h>
 #include <stdbool.h>
-#else
-typedef int bool;
-#define true 1
-#define false 0
-#endif
 #include <errno.h>
 #include <ruby.h>
-#if defined(HAVE_NATIVETHREAD) && defined(HAVE_RB_THREAD_BLOCKING_REGION) && !defined(_WIN32)
+#include <ruby/thread.h>
+#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32)
 #  include <signal.h>
 #  include <pthread.h>
 #endif
@@ -67,7 +71,7 @@ typedef int bool;
 #define FLOAT32_ADJ (4)
 #define FLOAT64_ADJ (8)
 #define ADDRESS_ADJ (sizeof(void *))
-#define LONGDOUBLE_ADJ (ffi_type_longdouble.alignment)
+#define LONGDOUBLE_ADJ (ffi_type_longdouble.alignment > sizeof(long double) ? ffi_type_longdouble.alignment : sizeof(long double))
 
 #endif /* USE_RAW */
 
@@ -79,7 +83,6 @@ typedef int bool;
 
 static void* callback_param(VALUE proc, VALUE cbinfo);
 static inline void* getPointer(VALUE value, int type);
-static inline char* getString(VALUE value, int type);
 
 static ID id_to_ptr, id_map_symbol, id_to_native;
 
@@ -106,7 +109,7 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
         Type* paramType = paramTypes[i];
         int type;
 
-        
+
         if (unlikely(paramType->nativeType == NATIVE_MAPPED)) {
             VALUE values[] = { argv[argidx], Qnil };
             argv[argidx] = rb_funcall2(((MappedType *) paramType)->rbConverter, id_to_native, 2, values);
@@ -119,19 +122,30 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
         switch (paramType->nativeType) {
 
             case NATIVE_INT8:
-                param->s8 = NUM2INT(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->s8 = NUM2INT(value);
+                } else {
+                    param->s8 = NUM2INT(argv[argidx]);
+                }
+
                 ++argidx;
                 ADJ(param, INT8);
                 break;
 
-
             case NATIVE_INT16:
-                param->s16 = NUM2INT(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->s16 = NUM2INT(value);
+
+                } else {
+                    param->s16 = NUM2INT(argv[argidx]);
+                }
+
                 ++argidx;
                 ADJ(param, INT16);
                 break;
 
-
             case NATIVE_INT32:
                 if (unlikely(type == T_SYMBOL && enums != Qnil)) {
                     VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
@@ -145,7 +159,6 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
                 ADJ(param, INT32);
                 break;
 
-
             case NATIVE_BOOL:
                 if (type != T_TRUE && type != T_FALSE) {
                     rb_raise(rb_eTypeError, "wrong argument type  (expected a boolean parameter)");
@@ -154,75 +167,137 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
                 ADJ(param, INT8);
                 break;
 
-
             case NATIVE_UINT8:
-                param->u8 = NUM2UINT(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->u8 = NUM2UINT(value);
+                } else {
+                    param->u8 = NUM2UINT(argv[argidx]);
+                }
+
                 ADJ(param, INT8);
                 ++argidx;
                 break;
 
-
             case NATIVE_UINT16:
-                param->u16 = NUM2UINT(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->u16 = NUM2UINT(value);
+                } else {
+                    param->u16 = NUM2UINT(argv[argidx]);
+                }
+
                 ADJ(param, INT16);
                 ++argidx;
                 break;
 
-
             case NATIVE_UINT32:
-                param->u32 = NUM2UINT(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->u32 = NUM2UINT(value);
+                } else {
+                    param->u32 = NUM2UINT(argv[argidx]);
+                }
+
                 ADJ(param, INT32);
                 ++argidx;
                 break;
 
-
             case NATIVE_INT64:
-                param->i64 = NUM2LL(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->i64 = NUM2LL(value);
+                } else {
+                    param->i64 = NUM2LL(argv[argidx]);
+                }
+
                 ADJ(param, INT64);
                 ++argidx;
                 break;
 
-
             case NATIVE_UINT64:
-                param->u64 = NUM2ULL(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->u64 = NUM2ULL(value);
+                } else {
+                    param->u64 = NUM2ULL(argv[argidx]);
+                }
+
                 ADJ(param, INT64);
                 ++argidx;
                 break;
 
             case NATIVE_LONG:
-                *(ffi_sarg *) param = NUM2LONG(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    *(ffi_sarg *) param = NUM2LONG(value);
+                } else {
+                    *(ffi_sarg *) param = NUM2LONG(argv[argidx]);
+                }
+
                 ADJ(param, LONG);
                 ++argidx;
                 break;
 
             case NATIVE_ULONG:
-                *(ffi_arg *) param = NUM2ULONG(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    *(ffi_arg *) param = NUM2ULONG(value);
+                } else {
+                    *(ffi_arg *) param = NUM2ULONG(argv[argidx]);
+                }
+
                 ADJ(param, LONG);
                 ++argidx;
                 break;
 
             case NATIVE_FLOAT32:
-                param->f32 = (float) NUM2DBL(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->f32 = (float) NUM2DBL(value);
+                } else {
+                    param->f32 = (float) NUM2DBL(argv[argidx]);
+                }
+
                 ADJ(param, FLOAT32);
                 ++argidx;
                 break;
 
             case NATIVE_FLOAT64:
-                param->f64 = NUM2DBL(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->f64 = NUM2DBL(value);
+                } else {
+                    param->f64 = NUM2DBL(argv[argidx]);
+                }
+
                 ADJ(param, FLOAT64);
                 ++argidx;
                 break;
 
             case NATIVE_LONGDOUBLE:
-                param->ld = rbffi_num2longdouble(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->ld = rbffi_num2longdouble(value);
+                } else {
+                    param->ld = rbffi_num2longdouble(argv[argidx]);
+                }
+
                 ADJ(param, LONGDOUBLE);
                 ++argidx;
                 break;
 
 
             case NATIVE_STRING:
-                param->ptr = getString(argv[argidx++], type);
+                if (type == T_NIL) {
+                    param->ptr = NULL;
+
+                } else {
+                    param->ptr = StringValueCStr(argv[argidx]);
+                }
+
                 ADJ(param, ADDRESS);
+                ++argidx;
                 break;
 
             case NATIVE_POINTER:
@@ -235,7 +310,6 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
 
 
             case NATIVE_FUNCTION:
-            case NATIVE_CALLBACK:
                 if (callbackProc != Qnil) {
                     param->ptr = callback_param(callbackProc, callbackParameters[cbidx++]);
                 } else {
@@ -255,45 +329,28 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
     }
 }
 
-
-typedef struct BlockingCall_ {
-    void* function;
-    FunctionType* info;
-    void **ffiValues;
-    void* retval;
-    void* stkretval;
-    void* params;
-} BlockingCall;
-
-static VALUE
+static void *
 call_blocking_function(void* data)
 {
-    BlockingCall* b = (BlockingCall *) data;
-
-    ffi_call(&b->info->ffi_cif, FFI_FN(b->function), b->retval, b->ffiValues);
+    rbffi_blocking_call_t* b = (rbffi_blocking_call_t *) data;
+    ffi_call(&b->cif, FFI_FN(b->function), b->retval, b->ffiValues);
 
-    return Qnil;
+    return NULL;
 }
 
-static VALUE
-do_blocking_call(void *data)
+VALUE
+rbffi_do_blocking_call(VALUE data)
 {
-    rbffi_thread_blocking_region(call_blocking_function, data, (void *) -1, NULL);
+    rb_thread_call_without_gvl(call_blocking_function, (void*)data, (rb_unblock_function_t *) -1, NULL);
 
     return Qnil;
 }
 
-static VALUE
-cleanup_blocking_call(void *data)
+VALUE
+rbffi_save_frame_exception(VALUE data, VALUE exc)
 {
-    BlockingCall* bc = (BlockingCall *) data;
-
-    memcpy(bc->stkretval, bc->retval, MAX(bc->info->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
-    xfree(bc->params);
-    xfree(bc->ffiValues);
-    xfree(bc->retval);
-    xfree(bc);
-
+    rbffi_frame_t* frame = (rbffi_frame_t *) data;
+    frame->exc = exc;
     return Qnil;
 }
 
@@ -304,36 +361,32 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
     void** ffiValues;
     FFIStorage* params;
     VALUE rbReturnValue;
-    
-#if !defined(HAVE_RUBY_THREAD_HAS_GVL_P)
-    rbffi_thread_t oldThread;
-#endif
+    rbffi_frame_t frame = { 0 };
 
     retval = alloca(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
-    
+
     if (unlikely(fnInfo->blocking)) {
-        BlockingCall* bc;
-
-        /*
-         * due to the way thread switching works on older ruby variants, we
-         * cannot allocate anything passed to the blocking function on the stack
-         */
-        ffiValues = ALLOC_N(void *, fnInfo->parameterCount);
-        params = ALLOC_N(FFIStorage, fnInfo->parameterCount);
-        bc = ALLOC_N(BlockingCall, 1);
-        bc->info = fnInfo;
+        rbffi_blocking_call_t* bc;
+
+        /* allocate information passed to the blocking function on the stack */
+        ffiValues = ALLOCA_N(void *, fnInfo->parameterCount);
+        params = ALLOCA_N(FFIStorage, fnInfo->parameterCount);
+        bc = ALLOCA_N(rbffi_blocking_call_t, 1);
+        bc->retval = retval;
+        bc->cif = fnInfo->ffi_cif;
         bc->function = function;
         bc->ffiValues = ffiValues;
         bc->params = params;
-        bc->retval = xmalloc(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
-        bc->stkretval = retval;
+        bc->frame = &frame;
 
         rbffi_SetupCallParams(argc, argv,
             fnInfo->parameterCount, fnInfo->parameterTypes, params, ffiValues,
             fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
-        
-        rb_ensure(do_blocking_call, (VALUE) bc, cleanup_blocking_call, (VALUE) bc);
-        
+
+        rbffi_frame_push(&frame);
+        rb_rescue2(rbffi_do_blocking_call, (VALUE) bc, rbffi_save_frame_exception, (VALUE) &frame, rb_eException, (VALUE) 0);
+        rbffi_frame_pop(&frame);
+
     } else {
 
         ffiValues = ALLOCA_N(void *, fnInfo->parameterCount);
@@ -343,24 +396,22 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
             fnInfo->parameterCount, fnInfo->parameterTypes, params, ffiValues,
             fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
 
-#if !defined(HAVE_RUBY_THREAD_HAS_GVL_P)
-        oldThread = rbffi_active_thread;
-        rbffi_active_thread = rbffi_thread_self();
-#endif
+        rbffi_frame_push(&frame);
         ffi_call(&fnInfo->ffi_cif, FFI_FN(function), retval, ffiValues);
-
-#if !defined(HAVE_RUBY_THREAD_HAS_GVL_P)
-        rbffi_active_thread = oldThread;
-#endif
+        rbffi_frame_pop(&frame);
     }
 
     if (unlikely(!fnInfo->ignoreErrno)) {
         rbffi_save_errno();
-    }    
-    
+    }
+
+    if (RTEST(frame.exc) && frame.exc != Qnil) {
+        rb_exc_raise(frame.exc);
+    }
+
     RB_GC_GUARD(rbReturnValue) = rbffi_NativeValue_ToRuby(fnInfo->returnType, fnInfo->rbReturnType, retval);
     RB_GC_GUARD(fnInfo->rbReturnType);
-    
+
     return rbReturnValue;
 }
 
@@ -378,9 +429,6 @@ getPointer(VALUE value, int type)
 
     } else if (type == T_STRING) {
 
-        if (rb_safe_level() >= 1 && OBJ_TAINTED(value)) {
-            rb_raise(rb_eSecurityError, "Unsafe string parameter");
-        }
         return StringValuePtr(value);
 
     } else if (type == T_NIL) {
@@ -400,25 +448,6 @@ getPointer(VALUE value, int type)
     return NULL;
 }
 
-static inline char*
-getString(VALUE value, int type)
-{
-    if (type == T_STRING) {
-
-        if (rb_safe_level() >= 1 && OBJ_TAINTED(value)) {
-            rb_raise(rb_eSecurityError, "Unsafe string parameter");
-        }
-
-        return StringValueCStr(value);
-
-    } else if (type == T_NIL) {
-        return NULL;
-    }
-
-    rb_raise(rb_eArgError, "Invalid String value");
-}
-
-
 Invoker
 rbffi_GetInvoker(FunctionType *fnInfo)
 {

data/ext/ffi_c/Call.h

@@ -4,25 +4,36 @@
  * Copyright (c) 2009, Mike Dalessio <mike.dalessio@gmail.com>
  * Copyright (c) 2009, Aman Gupta.
  *
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
  * All rights reserved.
  *
- * This file is part of ruby-ffi.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the Ruby FFI project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
  *
- * This code is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
- * version 3 for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef RBFFI_INVOKE_H
-#define	RBFFI_INVOKE_H
+#ifndef RBFFI_CALL_H
+#define	RBFFI_CALL_H
+
+#include "Thread.h"
 
 #ifdef	__cplusplus
 extern "C" {
@@ -37,7 +48,7 @@ extern "C" {
 #if (defined(__i386__) || defined(__x86_64__)) && !(defined(_WIN32) || defined(__WIN32__))
 #  define BYPASS_FFI 1
 #endif
-    
+
 typedef union {
 #ifdef USE_RAW
     signed int s8, s16, s32;
@@ -60,25 +71,37 @@ typedef union {
     long double ld;
 } FFIStorage;
 
-
 extern void rbffi_Call_Init(VALUE moduleFFI);
 
 extern void rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
         FFIStorage* paramStorage, void** ffiValues,
         VALUE* callbackParameters, int callbackCount, VALUE enums);
 
-extern VALUE rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo);
+struct FunctionType_;
+extern VALUE rbffi_CallFunction(int argc, VALUE* argv, void* function, struct FunctionType_* fnInfo);
 
-typedef VALUE (*Invoker)(int argc, VALUE* argv, void* function, FunctionType* fnInfo);
+typedef VALUE (*Invoker)(int argc, VALUE* argv, void* function, struct FunctionType_* fnInfo);
 
-Invoker rbffi_GetInvoker(FunctionType* fnInfo);
+Invoker rbffi_GetInvoker(struct FunctionType_* fnInfo);
 
 extern VALUE rbffi_GetEnumValue(VALUE enums, VALUE value);
 extern int rbffi_GetSignedIntValue(VALUE value, int type, int minValue, int maxValue, const char* typeName, VALUE enums);
 
+typedef struct rbffi_blocking_call {
+    rbffi_frame_t* frame;
+    void* function;
+    ffi_cif cif;
+    void **ffiValues;
+    void* retval;
+    void* params;
+} rbffi_blocking_call_t;
+
+VALUE rbffi_do_blocking_call(VALUE data);
+VALUE rbffi_save_frame_exception(VALUE data, VALUE exc);
+
 #ifdef	__cplusplus
 }
 #endif
 
-#endif	/* RBFFI_INVOKE_H */
+#endif	/* RBFFI_CALL_H */