pkcs11 0.2.4-x64-mingw32

data/ext/pk11_struct_macros.h

@@ -0,0 +1,435 @@
+#ifndef PK11_STRUCT_MACROS_INCLUDED
+#define PK11_STRUCT_MACROS_INCLUDED
+
+/**************************************************/
+/* struct/attribute implementation                */
+/**************************************************/
+
+#define HANDLE2NUM(n) ULONG2NUM(n)
+#define NUM2HANDLE(n) PKNUM2ULONG(n)
+#define PKNUM2ULONG(n) pkcs11_num2ulong(n)
+
+static VALUE
+pkcs11_num2ulong(VALUE val)
+{
+  if (TYPE(val) == T_BIGNUM || TYPE(val) == T_FIXNUM) {
+    return NUM2ULONG(val);
+  }
+  return NUM2ULONG(rb_to_int(val));
+}
+
+static VALUE
+get_string(VALUE obj, off_t offset, size_t size)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  return rb_str_new(ptr+offset, size);
+}
+
+static VALUE
+set_string(VALUE obj, VALUE value, off_t offset, size_t size)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  int len = size;
+  StringValue(value);
+  if (RSTRING_LEN(value) < len) len = RSTRING_LEN(value);
+  memset(ptr+offset, 0, size);
+  memcpy(ptr+offset, RSTRING_PTR(value), len);
+  return value;
+}
+
+static VALUE
+get_ulong(VALUE obj, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  return ULONG2NUM(*(CK_ULONG_PTR)(ptr+offset));
+}
+
+static VALUE
+set_ulong(VALUE obj, VALUE value, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  *(CK_ULONG_PTR)(ptr+offset) = NUM2ULONG(value);
+  return value;
+}
+
+static VALUE
+get_byte(VALUE obj, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  return ULONG2NUM(*(CK_BYTE_PTR)(ptr+offset));
+}
+
+static VALUE
+set_byte(VALUE obj, VALUE value, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  *(CK_BYTE_PTR)(ptr+offset) = NUM2ULONG(value);
+  return value;
+}
+
+static VALUE
+get_ulong_ptr(VALUE obj, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  CK_ULONG_PTR p = *(CK_ULONG_PTR *)(ptr+offset);
+  if (!p) return Qnil;
+  return ULONG2NUM(*p);
+}
+
+static VALUE
+set_ulong_ptr(VALUE obj, VALUE value, const char *name, off_t offset)
+{
+  VALUE new_obj;
+  CK_ULONG_PTR *ptr = (CK_ULONG_PTR *)((char*)DATA_PTR(obj) + offset);
+  if (NIL_P(value)){
+    rb_iv_set(obj, name, value);
+    *ptr = NULL_PTR;
+    return value;
+  }
+  new_obj = Data_Make_Struct(rb_cInteger, CK_ULONG, 0, free, *ptr);
+  rb_iv_set(obj, name, new_obj);
+  **ptr = NUM2ULONG(value);
+  return value;
+}
+
+static VALUE
+get_handle(VALUE obj, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  return HANDLE2NUM(*(CK_OBJECT_HANDLE_PTR)(ptr+offset));
+}
+
+static VALUE
+set_handle(VALUE obj, VALUE value, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  *(CK_OBJECT_HANDLE_PTR)(ptr+offset) = NUM2HANDLE(value);
+  return value;
+}
+
+static VALUE
+get_bool(VALUE obj, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  if(*(CK_BBOOL*)(ptr+offset)) return Qtrue;
+  else return Qfalse;
+}
+
+static VALUE
+set_bool(VALUE obj, VALUE value, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  if(value == Qfalse) *(CK_BBOOL*)(ptr+offset) = 0;
+  else if(value == Qtrue) *(CK_BBOOL*)(ptr+offset) = 1;
+  else rb_raise(rb_eArgError, "arg must be true or false");
+  return value;
+}
+
+static VALUE
+get_string_ptr(VALUE obj, const char *name, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  char *p = *(char**)(ptr+offset);
+  if (!p) return Qnil;
+  return rb_str_new2(p);
+}
+
+static VALUE
+set_string_ptr(VALUE obj, VALUE value, const char *name, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  if (NIL_P(value)){
+    rb_iv_set(obj, name, value);
+    *(CK_VOID_PTR*)(ptr+offset) = NULL_PTR;
+    return value;
+  }
+  StringValue(value);
+  value = rb_obj_freeze(rb_str_dup(value));
+  rb_iv_set(obj, name, value);
+  *(CK_VOID_PTR*)(ptr+offset) = RSTRING_PTR(value);
+  return value;
+}
+
+static VALUE
+get_string_ptr_len(VALUE obj, const char *name, off_t offset, off_t offset_len)
+{
+  unsigned long l;
+  char *ptr = (char*)DATA_PTR(obj);
+  char *p = *(char**)(ptr+offset);
+  if (!p) return Qnil;
+  l = *(unsigned long*)(ptr+offset_len);
+  return rb_str_new(p, l);
+}
+
+static VALUE
+set_string_ptr_len(VALUE obj, VALUE value, const char *name, off_t offset, off_t offset_len)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  if (NIL_P(value)){
+    rb_iv_set(obj, name, value);
+    *(CK_VOID_PTR*)(ptr+offset) = NULL_PTR;
+    *(unsigned long*)(ptr+offset_len) = 0;
+    return value;
+  }
+  StringValue(value);
+  value = rb_obj_freeze(rb_str_dup(value));
+  rb_iv_set(obj, name, value);
+  *(CK_VOID_PTR*)(ptr+offset) = RSTRING_PTR(value);
+  *(unsigned long*)(ptr+offset_len) = RSTRING_LEN(value);
+  return value;
+}
+
+static VALUE
+get_struct_inline(VALUE obj, VALUE klass, const char *name, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj) + offset;
+  VALUE inline_obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  rb_iv_set(inline_obj, name, obj);
+  return inline_obj;
+}
+
+static VALUE
+set_struct_inline(VALUE obj, VALUE klass, const char *struct_name, VALUE value, const char *name, off_t offset, int sizeofstruct)
+{
+  char *ptr = (char*)DATA_PTR(obj) + offset;
+  if (!rb_obj_is_kind_of(value, klass))
+    rb_raise(rb_eArgError, "arg must be a PKCS11::%s", struct_name);
+  memcpy(ptr, DATA_PTR(value), sizeofstruct);
+  return value;
+}
+
+static VALUE
+get_struct_ptr(VALUE obj, VALUE klass, const char *name, off_t offset, int sizeofstruct)
+{
+  char *ptr = (char*)DATA_PTR(obj);
+  char *p = *(char**)(ptr+offset);
+  void *mem;
+  VALUE new_obj;
+  if (!p) return Qnil;
+  mem = xmalloc(sizeofstruct);
+  memcpy(mem, p, sizeofstruct);
+  new_obj = Data_Wrap_Struct(klass, 0, -1, mem);
+  return new_obj;
+}
+
+static VALUE
+set_struct_ptr(VALUE obj, VALUE klass, const char *struct_name, VALUE value, const char *name, off_t offset)
+{
+  char *ptr = (char*)DATA_PTR(obj) + offset;
+  if (NIL_P(value)){
+    rb_iv_set(obj, name, value);
+    *(CK_VOID_PTR*)ptr = NULL_PTR;
+    return value;
+  }
+  if (!rb_obj_is_kind_of(value, klass))
+    rb_raise(rb_eArgError, "arg must be a PKCS11::%s", struct_name);
+  *(CK_VOID_PTR*)ptr = DATA_PTR(value);
+  rb_iv_set(obj, name, value);
+  return value;
+}
+
+static VALUE
+get_struct_ptr_array(VALUE obj, VALUE klass, off_t offset, off_t offset_len, int sizeofstruct)
+{
+  unsigned long i;
+  char *ptr = DATA_PTR(obj);
+  char *p = *(char **)(ptr+offset);
+  unsigned long l = *(unsigned long*)(ptr+offset_len);
+  VALUE ary = rb_ary_new();
+  for (i = 0; i < l; i++){
+    VALUE new_obj;
+    void *mem = xmalloc(sizeofstruct);
+    memcpy(mem, p + sizeofstruct * i, sizeofstruct);
+    new_obj = Data_Wrap_Struct(klass, 0, -1, mem);
+    rb_ary_push(ary, new_obj);
+  }
+  return ary;
+}
+
+static VALUE
+set_struct_ptr_array(VALUE obj, VALUE klass, const char *struct_name, VALUE value, const char *name, off_t offset, off_t offset_len, int sizeofstruct)
+{
+  int i;
+  VALUE str_buf;
+  char *ptr = DATA_PTR(obj);
+  Check_Type(value, T_ARRAY);
+
+  str_buf = rb_str_buf_new(sizeofstruct * RARRAY_LEN(value));
+
+  for (i = 0; i < RARRAY_LEN(value); i++){
+    VALUE entry = rb_ary_entry(value, i);
+    if (!rb_obj_is_kind_of(entry, klass))
+      rb_raise(rb_eArgError, "arg must be array of PKCS11::%s", struct_name);
+    memcpy(RSTRING_PTR(str_buf) + sizeofstruct * i, DATA_PTR(entry), sizeofstruct);
+  }
+  *(CK_VOID_PTR*)(ptr+offset) = RSTRING_PTR(str_buf);
+  *(unsigned long*)(ptr+offset_len) = RARRAY_LEN(value);
+  rb_iv_set(obj, name, str_buf);
+  return value;
+}
+
+
+#define OFFSET_OF(s, f) ((off_t)((char*)&(((s*)0)->f) - (char*)0))
+#define SIZE_OF(s, f) (sizeof(((s*)0)->f))
+
+#define PKCS11_IMPLEMENT_ALLOCATOR(s) \
+static VALUE s##_s_alloc(VALUE self){ \
+  s *info; \
+  VALUE obj = Data_Make_Struct(self, s, 0, -1, info); \
+  return obj; \
+} \
+static VALUE c##s##_to_s(VALUE self){ \
+  return rb_str_new(DATA_PTR(self), sizeof(s)); \
+} \
+static VALUE c##s##_members(VALUE self){ \
+  return a##s##_members; \
+}
+
+#define PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(s) \
+static VALUE c##s;\
+static VALUE a##s##_members;\
+PKCS11_IMPLEMENT_ALLOCATOR(s);
+
+#define PKCS11_IMPLEMENT_STRING_ACCESSOR(s, f) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  return get_string(o, OFFSET_OF(s, f), SIZE_OF(s, f)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  return set_string(o, v, OFFSET_OF(s, f), SIZE_OF(s, f)); \
+}
+
+#define PKCS11_IMPLEMENT_ULONG_ACCESSOR(s, f) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  return get_ulong(o, OFFSET_OF(s, f)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  return set_ulong(o, v, OFFSET_OF(s, f)); \
+}
+
+#define PKCS11_IMPLEMENT_BYTE_ACCESSOR(s, f) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  return get_byte(o, OFFSET_OF(s, f)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  return set_byte(o, v, OFFSET_OF(s, f)); \
+}
+
+#define PKCS11_IMPLEMENT_ULONG_PTR_ACCESSOR(s, f) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  return get_ulong_ptr(o, OFFSET_OF(s, f)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  return set_ulong_ptr(o, v, #f, OFFSET_OF(s, f)); \
+}
+
+#define PKCS11_IMPLEMENT_HANDLE_ACCESSOR(s, f) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  return get_handle(o, OFFSET_OF(s, f)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  return set_handle(o, v, OFFSET_OF(s, f)); \
+}
+
+#define PKCS11_IMPLEMENT_BOOL_ACCESSOR(s, f) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  return get_bool(o, OFFSET_OF(s, f)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  return set_bool(o, v, OFFSET_OF(s, f)); \
+}
+
+#define PKCS11_IMPLEMENT_STRING_PTR_ACCESSOR(s, f) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  return get_string_ptr(o, #f, OFFSET_OF(s, f)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  return set_string_ptr(o, v, #f, OFFSET_OF(s, f)); \
+}
+
+#define PKCS11_IMPLEMENT_STRING_PTR_LEN_ACCESSOR(s, f, l) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  return get_string_ptr_len(o, #f, OFFSET_OF(s, f), OFFSET_OF(s, l)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  return set_string_ptr_len(o, v, #f, OFFSET_OF(s, f), OFFSET_OF(s, l)); \
+}
+
+#define PKCS11_IMPLEMENT_STRUCT_ACCESSOR(s, k, f) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  return get_struct_inline(o, c##k, #f, OFFSET_OF(s, f)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  return set_struct_inline(o, c##k, #k, v, #f, OFFSET_OF(s, f), sizeof(k)); \
+}
+
+#define PKCS11_IMPLEMENT_PKCS11_STRUCT_ACCESSOR(s, k, f) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  VALUE klass = rb_const_get(rb_const_get(rb_cObject, rb_intern("PKCS11")), rb_intern(#k)); \
+  return get_struct_inline(o, klass, #f, OFFSET_OF(s, f)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  VALUE klass = rb_const_get(rb_const_get(rb_cObject, rb_intern("PKCS11")), rb_intern(#k)); \
+  return set_struct_inline(o, klass, #k, v, #f, OFFSET_OF(s, f), sizeof(k)); \
+}
+
+#define PKCS11_IMPLEMENT_STRUCT_PTR_ACCESSOR(s, k, f) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  return get_struct_ptr(o, c##k, #f, OFFSET_OF(s, f), sizeof(k)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  return set_struct_ptr(o, c##k, #k, v, #f, OFFSET_OF(s, f)); \
+}
+
+#define PKCS11_IMPLEMENT_PKCS11_STRUCT_PTR_ACCESSOR(s, k, f) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  VALUE klass = rb_const_get(rb_const_get(rb_cObject, rb_intern("PKCS11")), rb_intern(#k)); \
+  return get_struct_ptr(o, klass, #f, OFFSET_OF(s, f), sizeof(k)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  VALUE klass = rb_const_get(rb_const_get(rb_cObject, rb_intern("PKCS11")), rb_intern(#k)); \
+  return set_struct_ptr(o, klass, #k, v, #f, OFFSET_OF(s, f)); \
+}
+
+#define PKCS11_IMPLEMENT_STRUCT_PTR_ARRAY_ACCESSOR(s, k, f, l) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  return get_struct_ptr_array(o, c##k, OFFSET_OF(s, f), OFFSET_OF(s, l), sizeof(k)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  return set_struct_ptr_array(o, c##k, #k, v, #f, OFFSET_OF(s, f), OFFSET_OF(s, l), sizeof(k)); \
+}
+
+#define PKCS11_IMPLEMENT_PKCS11_STRUCT_PTR_ARRAY_ACCESSOR(s, k, f, l) \
+static VALUE c##s##_get_##f(VALUE o){ \
+  VALUE klass = rb_const_get(rb_const_get(rb_cObject, rb_intern("PKCS11")), rb_intern(#k)); \
+  return get_struct_ptr_array(o, klass, OFFSET_OF(s, f), OFFSET_OF(s, l), sizeof(k)); \
+} \
+static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
+  VALUE klass = rb_const_get(rb_const_get(rb_cObject, rb_intern("PKCS11")), rb_intern(#k)); \
+  return set_struct_ptr_array(o, klass, #k, v, #f, OFFSET_OF(s, f), OFFSET_OF(s, l), sizeof(k)); \
+}
+
+
+/**************************************************/
+/* struct/attribute definition                    */
+/**************************************************/
+
+#define PKCS11_DEFINE_STRUCT(s) \
+  do { \
+    c##s = rb_define_class_under(MODULE_FOR_STRUCTS, #s, BASECLASS_FOR_STRUCTS); \
+    a##s##_members = rb_ary_new(); \
+    rb_define_alloc_func(c##s, s##_s_alloc); \
+    rb_define_const(c##s, "SIZEOF_STRUCT", ULONG2NUM(sizeof(s))); \
+    rb_define_method(c##s, "to_s", c##s##_to_s, 0); \
+    rb_define_method(c##s, "members", c##s##_members, 0); \
+    rb_iv_set(c##s, "members", a##s##_members); \
+  } while(0)
+
+#define PKCS11_DEFINE_MEMBER(s, f) \
+  do { \
+    rb_define_method(c##s, #f, c##s##_get_##f, 0); \
+    rb_define_method(c##s, #f "=", c##s##_set_##f, 1); \
+    rb_ary_push(a##s##_members, rb_str_new2(#f)); \
+  } while(0)
+
+
+#endif

data/ext/pk11_thread_funcs.c

@@ -0,0 +1,411 @@
+  #include "pk11_thread_funcs.h"
+  #ifdef HAVE_RB_THREAD_BLOCKING_REGION
+      VALUE tbf_C_Initialize( void *data ){
+        struct tbr_C_Initialize_params *p = (struct tbr_C_Initialize_params*)data;
+        p->retval = p->func( p->params.pInitArgs );
+        return Qnil;
+      }
+
+      VALUE tbf_C_Finalize( void *data ){
+        struct tbr_C_Finalize_params *p = (struct tbr_C_Finalize_params*)data;
+        p->retval = p->func( p->params.pReserved );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GetInfo( void *data ){
+        struct tbr_C_GetInfo_params *p = (struct tbr_C_GetInfo_params*)data;
+        p->retval = p->func( p->params.pInfo );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GetFunctionList( void *data ){
+        struct tbr_C_GetFunctionList_params *p = (struct tbr_C_GetFunctionList_params*)data;
+        p->retval = p->func( p->params.ppFunctionList );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GetSlotList( void *data ){
+        struct tbr_C_GetSlotList_params *p = (struct tbr_C_GetSlotList_params*)data;
+        p->retval = p->func( p->params.tokenPresent,p->params.pSlotList,p->params.pulCount );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GetSlotInfo( void *data ){
+        struct tbr_C_GetSlotInfo_params *p = (struct tbr_C_GetSlotInfo_params*)data;
+        p->retval = p->func( p->params.slotID,p->params.pInfo );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GetTokenInfo( void *data ){
+        struct tbr_C_GetTokenInfo_params *p = (struct tbr_C_GetTokenInfo_params*)data;
+        p->retval = p->func( p->params.slotID,p->params.pInfo );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GetMechanismList( void *data ){
+        struct tbr_C_GetMechanismList_params *p = (struct tbr_C_GetMechanismList_params*)data;
+        p->retval = p->func( p->params.slotID,p->params.pMechanismList,p->params.pulCount );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GetMechanismInfo( void *data ){
+        struct tbr_C_GetMechanismInfo_params *p = (struct tbr_C_GetMechanismInfo_params*)data;
+        p->retval = p->func( p->params.slotID,p->params.type,p->params.pInfo );
+        return Qnil;
+      }
+
+      VALUE tbf_C_InitToken( void *data ){
+        struct tbr_C_InitToken_params *p = (struct tbr_C_InitToken_params*)data;
+        p->retval = p->func( p->params.slotID,p->params.pPin,p->params.ulPinLen,p->params.pLabel );
+        return Qnil;
+      }
+
+      VALUE tbf_C_InitPIN( void *data ){
+        struct tbr_C_InitPIN_params *p = (struct tbr_C_InitPIN_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pPin,p->params.ulPinLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_SetPIN( void *data ){
+        struct tbr_C_SetPIN_params *p = (struct tbr_C_SetPIN_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pOldPin,p->params.ulOldLen,p->params.pNewPin,p->params.ulNewLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_OpenSession( void *data ){
+        struct tbr_C_OpenSession_params *p = (struct tbr_C_OpenSession_params*)data;
+        p->retval = p->func( p->params.slotID,p->params.flags,p->params.pApplication,p->params.Notify,p->params.phSession );
+        return Qnil;
+      }
+
+      VALUE tbf_C_CloseSession( void *data ){
+        struct tbr_C_CloseSession_params *p = (struct tbr_C_CloseSession_params*)data;
+        p->retval = p->func( p->params.hSession );
+        return Qnil;
+      }
+
+      VALUE tbf_C_CloseAllSessions( void *data ){
+        struct tbr_C_CloseAllSessions_params *p = (struct tbr_C_CloseAllSessions_params*)data;
+        p->retval = p->func( p->params.slotID );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GetSessionInfo( void *data ){
+        struct tbr_C_GetSessionInfo_params *p = (struct tbr_C_GetSessionInfo_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pInfo );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GetOperationState( void *data ){
+        struct tbr_C_GetOperationState_params *p = (struct tbr_C_GetOperationState_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pOperationState,p->params.pulOperationStateLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_SetOperationState( void *data ){
+        struct tbr_C_SetOperationState_params *p = (struct tbr_C_SetOperationState_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pOperationState,p->params.ulOperationStateLen,p->params.hEncryptionKey,p->params.hAuthenticationKey );
+        return Qnil;
+      }
+
+      VALUE tbf_C_Login( void *data ){
+        struct tbr_C_Login_params *p = (struct tbr_C_Login_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.userType,p->params.pPin,p->params.ulPinLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_Logout( void *data ){
+        struct tbr_C_Logout_params *p = (struct tbr_C_Logout_params*)data;
+        p->retval = p->func( p->params.hSession );
+        return Qnil;
+      }
+
+      VALUE tbf_C_CreateObject( void *data ){
+        struct tbr_C_CreateObject_params *p = (struct tbr_C_CreateObject_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pTemplate,p->params.ulCount,p->params.phObject );
+        return Qnil;
+      }
+
+      VALUE tbf_C_CopyObject( void *data ){
+        struct tbr_C_CopyObject_params *p = (struct tbr_C_CopyObject_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.hObject,p->params.pTemplate,p->params.ulCount,p->params.phNewObject );
+        return Qnil;
+      }
+
+      VALUE tbf_C_DestroyObject( void *data ){
+        struct tbr_C_DestroyObject_params *p = (struct tbr_C_DestroyObject_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.hObject );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GetObjectSize( void *data ){
+        struct tbr_C_GetObjectSize_params *p = (struct tbr_C_GetObjectSize_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.hObject,p->params.pulSize );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GetAttributeValue( void *data ){
+        struct tbr_C_GetAttributeValue_params *p = (struct tbr_C_GetAttributeValue_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.hObject,p->params.pTemplate,p->params.ulCount );
+        return Qnil;
+      }
+
+      VALUE tbf_C_SetAttributeValue( void *data ){
+        struct tbr_C_SetAttributeValue_params *p = (struct tbr_C_SetAttributeValue_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.hObject,p->params.pTemplate,p->params.ulCount );
+        return Qnil;
+      }
+
+      VALUE tbf_C_FindObjectsInit( void *data ){
+        struct tbr_C_FindObjectsInit_params *p = (struct tbr_C_FindObjectsInit_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pTemplate,p->params.ulCount );
+        return Qnil;
+      }
+
+      VALUE tbf_C_FindObjects( void *data ){
+        struct tbr_C_FindObjects_params *p = (struct tbr_C_FindObjects_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.phObject,p->params.ulMaxObjectCount,p->params.pulObjectCount );
+        return Qnil;
+      }
+
+      VALUE tbf_C_FindObjectsFinal( void *data ){
+        struct tbr_C_FindObjectsFinal_params *p = (struct tbr_C_FindObjectsFinal_params*)data;
+        p->retval = p->func( p->params.hSession );
+        return Qnil;
+      }
+
+      VALUE tbf_C_EncryptInit( void *data ){
+        struct tbr_C_EncryptInit_params *p = (struct tbr_C_EncryptInit_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pMechanism,p->params.hKey );
+        return Qnil;
+      }
+
+      VALUE tbf_C_Encrypt( void *data ){
+        struct tbr_C_Encrypt_params *p = (struct tbr_C_Encrypt_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pData,p->params.ulDataLen,p->params.pEncryptedData,p->params.pulEncryptedDataLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_EncryptUpdate( void *data ){
+        struct tbr_C_EncryptUpdate_params *p = (struct tbr_C_EncryptUpdate_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pPart,p->params.ulPartLen,p->params.pEncryptedPart,p->params.pulEncryptedPartLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_EncryptFinal( void *data ){
+        struct tbr_C_EncryptFinal_params *p = (struct tbr_C_EncryptFinal_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pLastEncryptedPart,p->params.pulLastEncryptedPartLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_DecryptInit( void *data ){
+        struct tbr_C_DecryptInit_params *p = (struct tbr_C_DecryptInit_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pMechanism,p->params.hKey );
+        return Qnil;
+      }
+
+      VALUE tbf_C_Decrypt( void *data ){
+        struct tbr_C_Decrypt_params *p = (struct tbr_C_Decrypt_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pEncryptedData,p->params.ulEncryptedDataLen,p->params.pData,p->params.pulDataLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_DecryptUpdate( void *data ){
+        struct tbr_C_DecryptUpdate_params *p = (struct tbr_C_DecryptUpdate_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pEncryptedPart,p->params.ulEncryptedPartLen,p->params.pPart,p->params.pulPartLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_DecryptFinal( void *data ){
+        struct tbr_C_DecryptFinal_params *p = (struct tbr_C_DecryptFinal_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pLastPart,p->params.pulLastPartLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_DigestInit( void *data ){
+        struct tbr_C_DigestInit_params *p = (struct tbr_C_DigestInit_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pMechanism );
+        return Qnil;
+      }
+
+      VALUE tbf_C_Digest( void *data ){
+        struct tbr_C_Digest_params *p = (struct tbr_C_Digest_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pData,p->params.ulDataLen,p->params.pDigest,p->params.pulDigestLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_DigestUpdate( void *data ){
+        struct tbr_C_DigestUpdate_params *p = (struct tbr_C_DigestUpdate_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pPart,p->params.ulPartLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_DigestKey( void *data ){
+        struct tbr_C_DigestKey_params *p = (struct tbr_C_DigestKey_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.hKey );
+        return Qnil;
+      }
+
+      VALUE tbf_C_DigestFinal( void *data ){
+        struct tbr_C_DigestFinal_params *p = (struct tbr_C_DigestFinal_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pDigest,p->params.pulDigestLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_SignInit( void *data ){
+        struct tbr_C_SignInit_params *p = (struct tbr_C_SignInit_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pMechanism,p->params.hKey );
+        return Qnil;
+      }
+
+      VALUE tbf_C_Sign( void *data ){
+        struct tbr_C_Sign_params *p = (struct tbr_C_Sign_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pData,p->params.ulDataLen,p->params.pSignature,p->params.pulSignatureLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_SignUpdate( void *data ){
+        struct tbr_C_SignUpdate_params *p = (struct tbr_C_SignUpdate_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pPart,p->params.ulPartLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_SignFinal( void *data ){
+        struct tbr_C_SignFinal_params *p = (struct tbr_C_SignFinal_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pSignature,p->params.pulSignatureLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_SignRecoverInit( void *data ){
+        struct tbr_C_SignRecoverInit_params *p = (struct tbr_C_SignRecoverInit_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pMechanism,p->params.hKey );
+        return Qnil;
+      }
+
+      VALUE tbf_C_SignRecover( void *data ){
+        struct tbr_C_SignRecover_params *p = (struct tbr_C_SignRecover_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pData,p->params.ulDataLen,p->params.pSignature,p->params.pulSignatureLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_VerifyInit( void *data ){
+        struct tbr_C_VerifyInit_params *p = (struct tbr_C_VerifyInit_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pMechanism,p->params.hKey );
+        return Qnil;
+      }
+
+      VALUE tbf_C_Verify( void *data ){
+        struct tbr_C_Verify_params *p = (struct tbr_C_Verify_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pData,p->params.ulDataLen,p->params.pSignature,p->params.ulSignatureLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_VerifyUpdate( void *data ){
+        struct tbr_C_VerifyUpdate_params *p = (struct tbr_C_VerifyUpdate_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pPart,p->params.ulPartLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_VerifyFinal( void *data ){
+        struct tbr_C_VerifyFinal_params *p = (struct tbr_C_VerifyFinal_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pSignature,p->params.ulSignatureLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_VerifyRecoverInit( void *data ){
+        struct tbr_C_VerifyRecoverInit_params *p = (struct tbr_C_VerifyRecoverInit_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pMechanism,p->params.hKey );
+        return Qnil;
+      }
+
+      VALUE tbf_C_VerifyRecover( void *data ){
+        struct tbr_C_VerifyRecover_params *p = (struct tbr_C_VerifyRecover_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pSignature,p->params.ulSignatureLen,p->params.pData,p->params.pulDataLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_DigestEncryptUpdate( void *data ){
+        struct tbr_C_DigestEncryptUpdate_params *p = (struct tbr_C_DigestEncryptUpdate_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pPart,p->params.ulPartLen,p->params.pEncryptedPart,p->params.pulEncryptedPartLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_DecryptDigestUpdate( void *data ){
+        struct tbr_C_DecryptDigestUpdate_params *p = (struct tbr_C_DecryptDigestUpdate_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pEncryptedPart,p->params.ulEncryptedPartLen,p->params.pPart,p->params.pulPartLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_SignEncryptUpdate( void *data ){
+        struct tbr_C_SignEncryptUpdate_params *p = (struct tbr_C_SignEncryptUpdate_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pPart,p->params.ulPartLen,p->params.pEncryptedPart,p->params.pulEncryptedPartLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_DecryptVerifyUpdate( void *data ){
+        struct tbr_C_DecryptVerifyUpdate_params *p = (struct tbr_C_DecryptVerifyUpdate_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pEncryptedPart,p->params.ulEncryptedPartLen,p->params.pPart,p->params.pulPartLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GenerateKey( void *data ){
+        struct tbr_C_GenerateKey_params *p = (struct tbr_C_GenerateKey_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pMechanism,p->params.pTemplate,p->params.ulCount,p->params.phKey );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GenerateKeyPair( void *data ){
+        struct tbr_C_GenerateKeyPair_params *p = (struct tbr_C_GenerateKeyPair_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pMechanism,p->params.pPublicKeyTemplate,p->params.ulPublicKeyAttributeCount,p->params.pPrivateKeyTemplate,p->params.ulPrivateKeyAttributeCount,p->params.phPublicKey,p->params.phPrivateKey );
+        return Qnil;
+      }
+
+      VALUE tbf_C_WrapKey( void *data ){
+        struct tbr_C_WrapKey_params *p = (struct tbr_C_WrapKey_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pMechanism,p->params.hWrappingKey,p->params.hKey,p->params.pWrappedKey,p->params.pulWrappedKeyLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_UnwrapKey( void *data ){
+        struct tbr_C_UnwrapKey_params *p = (struct tbr_C_UnwrapKey_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pMechanism,p->params.hUnwrappingKey,p->params.pWrappedKey,p->params.ulWrappedKeyLen,p->params.pTemplate,p->params.ulAttributeCount,p->params.phKey );
+        return Qnil;
+      }
+
+      VALUE tbf_C_DeriveKey( void *data ){
+        struct tbr_C_DeriveKey_params *p = (struct tbr_C_DeriveKey_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pMechanism,p->params.hBaseKey,p->params.pTemplate,p->params.ulAttributeCount,p->params.phKey );
+        return Qnil;
+      }
+
+      VALUE tbf_C_SeedRandom( void *data ){
+        struct tbr_C_SeedRandom_params *p = (struct tbr_C_SeedRandom_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.pSeed,p->params.ulSeedLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GenerateRandom( void *data ){
+        struct tbr_C_GenerateRandom_params *p = (struct tbr_C_GenerateRandom_params*)data;
+        p->retval = p->func( p->params.hSession,p->params.RandomData,p->params.ulRandomLen );
+        return Qnil;
+      }
+
+      VALUE tbf_C_GetFunctionStatus( void *data ){
+        struct tbr_C_GetFunctionStatus_params *p = (struct tbr_C_GetFunctionStatus_params*)data;
+        p->retval = p->func( p->params.hSession );
+        return Qnil;
+      }
+
+      VALUE tbf_C_CancelFunction( void *data ){
+        struct tbr_C_CancelFunction_params *p = (struct tbr_C_CancelFunction_params*)data;
+        p->retval = p->func( p->params.hSession );
+        return Qnil;
+      }
+
+      VALUE tbf_C_WaitForSlotEvent( void *data ){
+        struct tbr_C_WaitForSlotEvent_params *p = (struct tbr_C_WaitForSlotEvent_params*)data;
+        p->retval = p->func( p->params.flags,p->params.pSlot,p->params.pRserved );
+        return Qnil;
+      }
+
+  #endif