ruby-oci8 2.1.7 → 2.1.8

data/ext/oci8/plthook_win32.c

@@ -0,0 +1,376 @@
+/* -*- indent-tabs-mode: nil -*-
+ *
+ * plthook_win32.c -- implemention of plthook for PE format
+ *
+ * URL: https://github.com/kubo/plthook
+ *
+ * ------------------------------------------------------
+ *
+ * Copyright 2013-2014 Kubo Takehiro <kubo@jiubao.org>
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''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> OR
+ * CONTRIBUTORS 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.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of the authors.
+ *
+ */
+#include <stdio.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <windows.h>
+#include <dbghelp.h>
+#include "plthook.h"
+
+#ifdef _MSC_VER
+#pragma comment(lib, "dbghelp.lib")
+#endif
+
+#ifndef _Printf_format_string_
+#define _Printf_format_string_
+#endif
+#ifndef __GNUC__
+#define __attribute__(arg)
+#endif
+
+#ifdef _WIN64
+#define SIZE_T_FMT "I64u"
+#else
+#define SIZE_T_FMT "u"
+#endif
+
+typedef struct {
+    const char *mod_name;
+    const char *name;
+    void **addr;
+} import_address_entry_t;
+
+struct plthook {
+    HMODULE hMod;
+    unsigned int num_entries;
+    import_address_entry_t entries[1];
+};
+
+static char errbuf[512];
+static int plthook_open_real(plthook_t **plthook_out, HMODULE hMod);
+static void set_errmsg(_Printf_format_string_ const char *fmt, ...) __attribute__((__format__ (__printf__, 1, 2)));
+static void set_errmsg2(_Printf_format_string_ const char *fmt, ...) __attribute__((__format__ (__printf__, 1, 2)));
+static const char *winsock2_ordinal2name(int ordinal);
+
+int plthook_open(plthook_t **plthook_out, const char *filename)
+{
+    HMODULE hMod;
+
+    *plthook_out = NULL;
+    if (!GetModuleHandleExA(0, filename, &hMod)) {
+        set_errmsg2("Cannot get module %s: ", filename);
+        return PLTHOOK_FILE_NOT_FOUND;
+    }
+    return plthook_open_real(plthook_out, hMod);
+}
+
+int plthook_open_by_address(plthook_t **plthook_out, void *address)
+{
+    HMODULE hMod;
+
+    *plthook_out = NULL;
+    if (!GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, address, &hMod)) {
+        set_errmsg2("Cannot get module at address %p: ", address);
+        return PLTHOOK_FILE_NOT_FOUND;
+    }
+    return plthook_open_real(plthook_out, hMod);
+}
+
+static int plthook_open_real(plthook_t **plthook_out, HMODULE hMod)
+{
+    plthook_t *plthook;
+    ULONG ulSize;
+    IMAGE_IMPORT_DESCRIPTOR *desc_head, *desc;
+    size_t num_entries = 0;
+    size_t ordinal_name_buflen = 0;
+    size_t idx;
+    char *ordinal_name_buf;
+
+    desc_head = (IMAGE_IMPORT_DESCRIPTOR*)ImageDirectoryEntryToData(hMod, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &ulSize);
+    if (desc_head == NULL) {
+        set_errmsg2("ImageDirectoryEntryToData error: ");
+        return PLTHOOK_INTERNAL_ERROR;
+    }
+
+    /* Calculate size to allocate memory.  */
+    for (desc = desc_head; desc->Name != 0; desc++) {
+        IMAGE_THUNK_DATA *name_thunk = (IMAGE_THUNK_DATA*)((char*)hMod + desc->OriginalFirstThunk);
+        IMAGE_THUNK_DATA *addr_thunk = (IMAGE_THUNK_DATA*)((char*)hMod + desc->FirstThunk);
+        int is_winsock2_dll = (stricmp((char *)hMod + desc->Name, "WS2_32.DLL") == 0);
+
+        while (addr_thunk->u1.Function != 0) {
+            if (IMAGE_SNAP_BY_ORDINAL(name_thunk->u1.Ordinal)) {
+                int ordinal = IMAGE_ORDINAL(name_thunk->u1.Ordinal);
+                const char *name = NULL;
+                if (is_winsock2_dll) {
+                    name = winsock2_ordinal2name(ordinal);
+                }
+                if (name == NULL) {
+                    char buf[64];
+                    ordinal_name_buflen += sprintf(buf, "#%d", ordinal) + 1;
+                }
+            }
+            num_entries++;
+            name_thunk++;
+            addr_thunk++;
+        }
+    }
+
+    plthook = calloc(1, offsetof(plthook_t, entries) + sizeof(import_address_entry_t) * num_entries + ordinal_name_buflen);
+    if (plthook == NULL) {
+        set_errmsg("failed to allocate memory: %" SIZE_T_FMT " bytes", sizeof(plthook_t));
+        return PLTHOOK_OUT_OF_MEMORY;
+    }
+    plthook->hMod = hMod;
+    plthook->num_entries = num_entries;
+
+    ordinal_name_buf = (char*)plthook + offsetof(plthook_t, entries) + sizeof(import_address_entry_t) * num_entries;
+    idx = 0;
+    for (desc = desc_head; desc->Name != 0; desc++) {
+        IMAGE_THUNK_DATA *name_thunk = (IMAGE_THUNK_DATA*)((char*)hMod + desc->OriginalFirstThunk);
+        IMAGE_THUNK_DATA *addr_thunk = (IMAGE_THUNK_DATA*)((char*)hMod + desc->FirstThunk);
+        int is_winsock2_dll = (stricmp((char *)hMod + desc->Name, "WS2_32.DLL") == 0);
+
+        while (addr_thunk->u1.Function != 0) {
+            const char *name = NULL;
+
+            if (IMAGE_SNAP_BY_ORDINAL(name_thunk->u1.Ordinal)) {
+                int ordinal = IMAGE_ORDINAL(name_thunk->u1.Ordinal);
+                if (is_winsock2_dll) {
+                    name = winsock2_ordinal2name(ordinal);
+                }
+                if (name == NULL) {
+                    ordinal_name_buf += sprintf(ordinal_name_buf, "#%d", ordinal) + 1;
+                }
+            } else {
+                name = (char*)((PIMAGE_IMPORT_BY_NAME)((char*)hMod + name_thunk->u1.AddressOfData))->Name;
+            }
+            plthook->entries[idx].mod_name = (char *)hMod + desc->Name;
+            plthook->entries[idx].name = name;
+            plthook->entries[idx].addr = (void**)&addr_thunk->u1.Function;
+            idx++;
+            name_thunk++;
+            addr_thunk++;
+        }
+    }
+
+    *plthook_out = plthook;
+    return 0;
+}
+
+int plthook_enum(plthook_t *plthook, unsigned int *pos, const char **name_out, void ***addr_out)
+{
+    if (*pos >= plthook->num_entries) {
+        *name_out = NULL;
+        *addr_out = NULL;
+        return EOF;
+    }
+    *name_out = plthook->entries[*pos].name;
+    *addr_out = plthook->entries[*pos].addr;
+    (*pos)++;
+    return 0;
+}
+
+static void replace_funcaddr(void **addr, void *newfunc, void **oldfunc)
+{
+    DWORD dwOld;
+    DWORD dwDummy;
+
+    if (oldfunc != NULL) {
+        *oldfunc = *addr;
+    }
+    VirtualProtect(addr, sizeof(void *), PAGE_EXECUTE_READWRITE, &dwOld);
+    *addr = newfunc;
+    VirtualProtect(addr, sizeof(void *), dwOld, &dwDummy);
+}
+
+int plthook_replace(plthook_t *plthook, const char *funcname, void *funcaddr, void **oldfunc)
+{
+#ifndef _WIN64
+    size_t funcnamelen = strlen(funcname);
+#endif
+    unsigned int pos = 0;
+    const char *name;
+    void **addr;
+    int rv;
+
+    if (plthook == NULL) {
+        set_errmsg("invalid argument: The first argument is null.");
+        return PLTHOOK_INVALID_ARGUMENT;
+    }
+    while ((rv = plthook_enum(plthook, &pos, &name, &addr)) == 0) {
+#ifdef _WIN64
+        if (strcmp(name, funcname) == 0) {
+            replace_funcaddr(addr, funcaddr, oldfunc);
+            return 0;
+        }
+#else
+        /* Function names may be decorated in Windows 32-bit applications. */
+        if (strncmp(name, funcname, funcnamelen) == 0) {
+            if (name[funcnamelen] == '\0' || name[funcnamelen] == '@') {
+                replace_funcaddr(addr, funcaddr, oldfunc);
+                return 0;
+            }
+        }
+        if (name[0] == '_' || name[0] == '@') {
+            name++;
+            if (strncmp(name, funcname, funcnamelen) == 0) {
+                if (name[funcnamelen] == '\0' || name[funcnamelen] == '@') {
+                    replace_funcaddr(addr, funcaddr, oldfunc);
+                    return 0;
+                }
+            }
+        }
+#endif
+    }
+    if (rv == EOF) {
+        set_errmsg("no such function: %s", funcname);
+        rv = PLTHOOK_FUNCTION_NOT_FOUND;
+    }
+    return rv;
+}
+
+void plthook_close(plthook_t *plthook)
+{
+    if (plthook != NULL) {
+        free(plthook);
+    }
+}
+
+const char *plthook_error(void)
+{
+    return errbuf;
+}
+
+static void set_errmsg(const char *fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(errbuf, sizeof(errbuf) - 1, fmt, ap);
+    va_end(ap);
+}
+
+static void set_errmsg2(const char *fmt, ...)
+{
+    va_list ap;
+    size_t len;
+
+    va_start(ap, fmt);
+    vsnprintf(errbuf, sizeof(errbuf) - 1, fmt, ap);
+    va_end(ap);
+    len = strlen(errbuf);
+    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_IGNORE_INSERTS,
+                   NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                   errbuf + len, sizeof(errbuf) - len - 1, NULL);
+}
+
+static const char *winsock2_ordinal2name(int ordinal)
+{
+    switch (ordinal) {
+    case 1: return "accept";
+    case 2: return "bind";
+    case 3: return "closesocket";
+    case 4: return "connect";
+    case 5: return "getpeername";
+    case 6: return "getsockname";
+    case 7: return "getsockopt";
+    case 8: return "htonl";
+    case 9: return "htons";
+    case 10: return "inet_addr";
+    case 11: return "inet_ntoa";
+    case 12: return "ioctlsocket";
+    case 13: return "listen";
+    case 14: return "ntohl";
+    case 15: return "ntohs";
+    case 16: return "recv";
+    case 17: return "recvfrom";
+    case 18: return "select";
+    case 19: return "send";
+    case 20: return "sendto";
+    case 21: return "setsockopt";
+    case 22: return "shutdown";
+    case 23: return "socket";
+    case 24: return "MigrateWinsockConfiguration";
+    case 51: return "gethostbyaddr";
+    case 52: return "gethostbyname";
+    case 53: return "getprotobyname";
+    case 54: return "getprotobynumber";
+    case 55: return "getservbyname";
+    case 56: return "getservbyport";
+    case 57: return "gethostname";
+    case 101: return "WSAAsyncSelect";
+    case 102: return "WSAAsyncGetHostByAddr";
+    case 103: return "WSAAsyncGetHostByName";
+    case 104: return "WSAAsyncGetProtoByNumber";
+    case 105: return "WSAAsyncGetProtoByName";
+    case 106: return "WSAAsyncGetServByPort";
+    case 107: return "WSAAsyncGetServByName";
+    case 108: return "WSACancelAsyncRequest";
+    case 109: return "WSASetBlockingHook";
+    case 110: return "WSAUnhookBlockingHook";
+    case 111: return "WSAGetLastError";
+    case 112: return "WSASetLastError";
+    case 113: return "WSACancelBlockingCall";
+    case 114: return "WSAIsBlocking";
+    case 115: return "WSAStartup";
+    case 116: return "WSACleanup";
+    case 151: return "__WSAFDIsSet";
+    case 500: return "WEP";
+    case 1000: return "WSApSetPostRoutine";
+    case 1001: return "WsControl";
+    case 1002: return "closesockinfo";
+    case 1003: return "Arecv";
+    case 1004: return "Asend";
+    case 1005: return "WSHEnumProtocols";
+    case 1100: return "inet_network";
+    case 1101: return "getnetbyname";
+    case 1102: return "rcmd";
+    case 1103: return "rexec";
+    case 1104: return "rresvport";
+    case 1105: return "sethostname";
+    case 1106: return "dn_expand";
+    case 1107: return "WSARecvEx";
+    case 1108: return "s_perror";
+    case 1109: return "GetAddressByNameA";
+    case 1110: return "GetAddressByNameW";
+    case 1111: return "EnumProtocolsA";
+    case 1112: return "EnumProtocolsW";
+    case 1113: return "GetTypeByNameA";
+    case 1114: return "GetTypeByNameW";
+    case 1115: return "GetNameByTypeA";
+    case 1116: return "GetNameByTypeW";
+    case 1117: return "SetServiceA";
+    case 1118: return "SetServiceW";
+    case 1119: return "GetServiceA";
+    case 1120: return "GetServiceW";
+    case 1130: return "NPLoadNameSpaces";
+    case 1131: return "NSPStartup";
+    case 1140: return "TransmitFile";
+    case 1141: return "AcceptEx";
+    case 1142: return "GetAcceptExSockaddrs";
+    }
+    return NULL;
+}

data/ext/oci8/stmt.c

@@ -3,14 +3,14 @@
  * stmt.c - part of ruby-oci8
  *         implement the methods of OCIStmt.
  *
- * Copyright (C) 2002-2012 KUBO Takehiro <kubo@jiubao.org>
+ * Copyright (C) 2002-2015 Kubo Takehiro <kubo@jiubao.org>
  *
  */
 #include "oci8.h"
 
-VALUE cOCIStmt;
+static VALUE cOCIStmt;
 
-#define TO_STMT(obj) ((oci8_stmt_t *)oci8_get_handle((obj), cOCIStmt))
+#define TO_STMT(obj) ((oci8_stmt_t *)oci8_check_typeddata((obj), &oci8_stmt_data_type, 1))
 
 typedef struct {
     oci8_base_t base;
@@ -31,28 +31,44 @@ static void oci8_stmt_free(oci8_base_t *base)
     if (stmt->use_stmt_release) {
         OCIStmtRelease(base->hp.stmt, oci8_errhp, NULL, 0, OCI_DEFAULT);
         base->type = 0;
+        base->closed = 1;
         stmt->use_stmt_release = 0;
     }
 }
 
-static oci8_base_vtable_t oci8_stmt_vtable = {
-    oci8_stmt_mark,
+static const oci8_handle_data_type_t oci8_stmt_data_type = {
+    {
+        "OCI8::Cursor",
+        {
+            (RUBY_DATA_FUNC)oci8_stmt_mark,
+            oci8_handle_cleanup,
+            oci8_handle_size,
+        },
+        &oci8_handle_data_type.rb_data_type, NULL,
+#ifdef RUBY_TYPED_WB_PROTECTED
+        RUBY_TYPED_WB_PROTECTED,
+#endif
+    },
     oci8_stmt_free,
     sizeof(oci8_stmt_t),
 };
 
+static VALUE oci8_stmt_alloc(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &oci8_stmt_data_type);
+}
+
 /*
- * call-seq:
- *   __initialize(connection, sql_statement)
+ * @overload __initialize(connection, sql_statement)
  *
- * @param [OCI8] connection
- * @param [String] sql_statement
+ *  @param [OCI8] connection
+ *  @param [String] sql_statement
  *
- * @private
+ *  @private
  */
 static VALUE oci8_stmt_initialize(VALUE self, VALUE svc, VALUE sql)
 {
-    oci8_stmt_t *stmt = DATA_PTR(self);
+    oci8_stmt_t *stmt = TO_STMT(self);
     oci8_svcctx_t *svcctx;
     sword rv;
 
@@ -81,36 +97,33 @@ static VALUE oci8_stmt_initialize(VALUE self, VALUE svc, VALUE sql)
             }
         }
     }
-    stmt->svc = svc;
+    RB_OBJ_WRITE(stmt->base.self, &stmt->svc, svc);
 
-    oci8_link_to_parent((oci8_base_t*)stmt, (oci8_base_t*)DATA_PTR(svc));
+    oci8_link_to_parent(&stmt->base, &svcctx->base);
     return Qnil;
 }
 
 /*
- * call-seq:
- *   __define(position, bindobj)
+ * @overload __define(position, bindobj)
  *
- * @param [Integer] position
- * @param [OCI8::BindType::Base] bindobj
+ *  @param [Integer] position
+ *  @param [OCI8::BindType::Base] bindobj
  *
- * @private
+ *  @private
  */
 static VALUE oci8_define_by_pos(VALUE self, VALUE vposition, VALUE vbindobj)
 {
     oci8_stmt_t *stmt = TO_STMT(self);
-    ub4 position;
-    oci8_bind_t *obind;
-    const oci8_bind_vtable_t *vptr;
+    ub4 position = NUM2INT(vposition);
+    oci8_bind_t *obind = TO_BIND(vbindobj);
+    const oci8_bind_data_type_t *data_type;
     sword status;
 
-    position = NUM2INT(vposition); /* 1 */
-    obind = oci8_get_bind(vbindobj); /* 2 */
     if (obind->base.hp.dfn != NULL) {
         oci8_base_free(&obind->base); /* TODO: OK? */
     }
-    vptr = (const oci8_bind_vtable_t *)obind->base.vptr;
-    status = OCIDefineByPos(stmt->base.hp.stmt, &obind->base.hp.dfn, oci8_errhp, position, obind->valuep, obind->value_sz, vptr->dty, NIL_P(obind->tdo) ? obind->u.inds : NULL, NULL, 0, OCI_DEFAULT);
+    data_type = (const oci8_bind_data_type_t *)obind->base.data_type;
+    status = OCIDefineByPos(stmt->base.hp.stmt, &obind->base.hp.dfn, oci8_errhp, position, obind->valuep, obind->value_sz, data_type->dty, NIL_P(obind->tdo) ? obind->u.inds : NULL, NULL, 0, OCI_DEFAULT);
     if (status != OCI_SUCCESS) {
         chker3(status, &stmt->base, stmt->base.hp.ptr);
     }
@@ -122,20 +135,19 @@ static VALUE oci8_define_by_pos(VALUE self, VALUE vposition, VALUE vbindobj)
     if (NIL_P(obind->tdo) && obind->maxar_sz > 0) {
         chker2(OCIDefineArrayOfStruct(obind->base.hp.dfn, oci8_errhp, obind->alloc_sz, sizeof(sb2), 0, 0), &stmt->base);
     }
-    if (vptr->post_bind_hook != NULL) {
-        vptr->post_bind_hook(obind);
+    if (data_type->post_bind_hook != NULL) {
+        data_type->post_bind_hook(obind);
     }
     return obind->base.self;
 }
 
 /*
- * call-seq:
- *   __bind(placeholder, bindobj)
+ * @overload __bind(placeholder, bindobj)
  *
- * @param [Integer, String or Symbol] placeholder
- * @param [OCI8::BindType::Base] bindobj
+ *  @param [Integer, String or Symbol] placeholder
+ *  @param [OCI8::BindType::Base] bindobj
  *
- * @private
+ *  @private
  */
 static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
 {
@@ -144,7 +156,7 @@ static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
     ub4 placeholder_len = 0;
     ub4 position = 0;
     oci8_bind_t *obind;
-    const oci8_bind_vtable_t *vptr;
+    const oci8_bind_data_type_t *data_type;
     sword status;
     void *indp;
 
@@ -152,8 +164,17 @@ static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
         placeholder_ptr = NULL;
         placeholder_len = 0;
     } else if (SYMBOL_P(vplaceholder)) {
+#ifdef HAVE_RB_SYM2STR
+        /* Don't use SYM2ID on ruby 2.2.0 or later.
+         * Symbols passed to SYM2ID are not GC'ed.
+         */
+        VALUE symval = rb_sym2str(vplaceholder);
+        const char *symname = RSTRING_PTR(symval);
+        size_t len = RSTRING_LEN(symval);
+#else
         const char *symname = rb_id2name(SYM2ID(vplaceholder));
         size_t len = strlen(symname);
+#endif
         placeholder_ptr = ALLOCA_N(char, len + 1);
         placeholder_len = len + 1;
         placeholder_ptr[0] = ':';
@@ -165,17 +186,17 @@ static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
         placeholder_ptr = RSTRING_PTR(vplaceholder);
         placeholder_len = RSTRING_LEN(vplaceholder);
     }
-    obind = oci8_get_bind(vbindobj); /* 2 */
+    obind = TO_BIND(vbindobj); /* 2 */
     if (obind->base.hp.bnd != NULL) {
         oci8_base_free(&obind->base); /* TODO: OK? */
     }
-    vptr = (const oci8_bind_vtable_t *)obind->base.vptr;
+    data_type = (const oci8_bind_data_type_t *)obind->base.data_type;
 
     indp = NIL_P(obind->tdo) ? obind->u.inds : NULL;
     if (placeholder_ptr == (char*)-1) {
-        status = OCIBindByPos(stmt->base.hp.stmt, &obind->base.hp.bnd, oci8_errhp, position, obind->valuep, obind->value_sz, vptr->dty, indp, NULL, 0, 0, 0, OCI_DEFAULT);
+        status = OCIBindByPos(stmt->base.hp.stmt, &obind->base.hp.bnd, oci8_errhp, position, obind->valuep, obind->value_sz, data_type->dty, indp, NULL, 0, 0, 0, OCI_DEFAULT);
     } else {
-        status = OCIBindByName(stmt->base.hp.stmt, &obind->base.hp.bnd, oci8_errhp, TO_ORATEXT(placeholder_ptr), placeholder_len, obind->valuep, obind->value_sz, vptr->dty, indp, NULL, 0, 0, 0, OCI_DEFAULT);
+        status = OCIBindByName(stmt->base.hp.stmt, &obind->base.hp.bnd, oci8_errhp, TO_ORATEXT(placeholder_ptr), placeholder_len, obind->valuep, obind->value_sz, data_type->dty, indp, NULL, 0, 0, 0, OCI_DEFAULT);
     }
     if (status != OCI_SUCCESS) {
         chker3(status, &stmt->base, stmt->base.hp.stmt);
@@ -189,8 +210,8 @@ static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
         chker2(OCIBindArrayOfStruct(obind->base.hp.bnd, oci8_errhp, obind->alloc_sz, sizeof(sb2), 0, 0),
                &stmt->base);
     }
-    if (vptr->post_bind_hook != NULL) {
-        vptr->post_bind_hook(obind);
+    if (data_type->post_bind_hook != NULL) {
+        data_type->post_bind_hook(obind);
     }
     return obind->base.self;
 }
@@ -213,12 +234,11 @@ static sword oci8_call_stmt_execute(oci8_svcctx_t *svcctx, oci8_stmt_t *stmt, ub
 }
 
 /*
- * call-seq:
- *   __execute(iteration_count)
+ * @overload __execute(iteration_count)
  *
- * @param [Integer] iteration_count
+ *  @param [Integer] iteration_count
  *
- * @private
+ *  @private
  */
 static VALUE oci8_stmt_execute(VALUE self, VALUE iteration_count)
 {
@@ -232,13 +252,15 @@ static VALUE oci8_stmt_execute(VALUE self, VALUE iteration_count)
 }
 
 /*
- * call-seq:
- *   __fetch(connection)
+ * @overload __fetch(connection)
+ *
+ *  Fetches one row and set the result to <code>@define_handles</code>.
+ *  This is called by private methods of OCI8::Cursor.
  *
- * @param [OCI8] connection
- * @return [true or false] true on success and false when all rows are fetched.
+ *  @param [OCI8] connection
+ *  @return [true or false] true on success and false when all rows are fetched.
  *
- * @private
+ *  @private
  */
 static VALUE oci8_stmt_fetch(VALUE self, VALUE svc)
 {
@@ -246,15 +268,15 @@ static VALUE oci8_stmt_fetch(VALUE self, VALUE svc)
     oci8_svcctx_t *svcctx = oci8_get_svcctx(svc);
     sword rv;
     oci8_bind_t *obind;
-    const oci8_bind_vtable_t *vptr;
+    const oci8_bind_data_type_t *data_type;
 
     if (stmt->base.children != NULL) {
         obind = (oci8_bind_t *)stmt->base.children;
         do {
             if (obind->base.type == OCI_HTYPE_DEFINE) {
-                vptr = (const oci8_bind_vtable_t *)obind->base.vptr;
-                if (vptr->pre_fetch_hook != NULL) {
-                    vptr->pre_fetch_hook(obind, stmt->svc);
+                data_type = (const oci8_bind_data_type_t *)obind->base.data_type;
+                if (data_type->pre_fetch_hook != NULL) {
+                    data_type->pre_fetch_hook(obind, stmt->svc);
                 }
             }
             obind = (oci8_bind_t *)obind->base.next;
@@ -269,13 +291,14 @@ static VALUE oci8_stmt_fetch(VALUE self, VALUE svc)
 }
 
 /*
- * call-seq:
- *   __paramGet(pos)
+ * @overload __paramGet(pos)
  *
- * @param [Fixnum] pos Column position which starts from one
- * @return [OCI8::Metadata::Base]
+ *  Returns the definition of column specified by <i>pos</i>
  *
- * @private
+ *  @param [Fixnum] pos Column position which starts from one
+ *  @return [OCI8::Metadata::Base]
+ *
+ *  @private
  */
 static VALUE oci8_stmt_get_param(VALUE self, VALUE pos)
 {
@@ -292,19 +315,19 @@ static VALUE oci8_stmt_get_param(VALUE self, VALUE pos)
 }
 
 /*
- * Get the rowid of the last inserted, updated or deleted row.
- * This cannot be used for select statements.
+ *  Gets the rowid of the last inserted, updated or deleted row.
+ *  This cannot be used for select statements.
  *
- * @example
- *   cursor = conn.parse('INSERT INTO foo_table values(:1, :2)', 1, 2)
- *   cursor.exec
- *   cursor.rowid # => "AAAFlLAAEAAAAG9AAA", the inserted row's rowid
+ *  @example
+ *    cursor = conn.parse('INSERT INTO foo_table values(:1, :2)', 1, 2)
+ *    cursor.exec
+ *    cursor.rowid # => "AAAFlLAAEAAAAG9AAA", the inserted row's rowid
  *
- * @return [String]
+ *  @return [String]
  */
 static VALUE oci8_stmt_get_rowid(VALUE self)
 {
-    oci8_base_t *base = oci8_get_handle(self, cOCIStmt);
+    oci8_base_t *base = oci8_check_typeddata(self, &oci8_stmt_data_type, 1);
     return oci8_get_rowid_attr(base, OCI_ATTR_ROWID, base->hp.stmt);
 }
 
@@ -321,12 +344,9 @@ VALUE oci8_stmt_get(oci8_bind_t *obind, void *data, void *null_struct)
 static void bind_stmt_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
 {
     oci8_hp_obj_t *oho = (oci8_hp_obj_t *)data;
-    oci8_base_t *h;
-    if (!rb_obj_is_instance_of(val, cOCIStmt))
-        rb_raise(rb_eArgError, "Invalid argument: %s (expect OCIStmt)", rb_class2name(CLASS_OF(val)));
-    h = DATA_PTR(val);
-    oho->hp = h->hp.ptr;
-    oho->obj = val;
+    oci8_stmt_t *stmt = TO_STMT(val);
+    oho->hp = stmt->base.hp.ptr;
+    RB_OBJ_WRITE(obind->base.self, &oho->obj, val);
 }
 
 static void bind_stmt_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
@@ -343,14 +363,26 @@ static void bind_stmt_init_elem(oci8_bind_t *obind, VALUE svc)
 
     do {
         oho[idx].obj = rb_class_new_instance(1, &svc, cOCIStmt);
+        RB_OBJ_WRITTEN(obind->base.self, Qundef, oho[idx].obj);
         h = DATA_PTR(oho[idx].obj);
         oho[idx].hp = h->hp.ptr;
     } while (++idx < obind->maxar_sz);
 }
 
-static const oci8_bind_vtable_t bind_stmt_vtable = {
+static const oci8_bind_data_type_t bind_stmt_data_type = {
     {
-        oci8_bind_hp_obj_mark,
+        {
+            "OCI8::BindType::Cursor",
+            {
+                (RUBY_DATA_FUNC)oci8_bind_hp_obj_mark,
+                oci8_handle_cleanup,
+                oci8_handle_size,
+            },
+            &oci8_bind_data_type.rb_data_type, NULL,
+#ifdef RUBY_TYPED_WB_PROTECTED
+            RUBY_TYPED_WB_PROTECTED,
+#endif
+        },
         oci8_bind_free,
         sizeof(oci8_bind_t)
     },
@@ -362,6 +394,11 @@ static const oci8_bind_vtable_t bind_stmt_vtable = {
     SQLT_RSET
 };
 
+static VALUE bind_stmt_alloc(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &bind_stmt_data_type.base);
+}
+
 void Init_oci8_stmt(VALUE cOCI8)
 {
 #if 0
@@ -369,7 +406,7 @@ void Init_oci8_stmt(VALUE cOCI8)
     cOCI8 = rb_define_class("OCI8", cOCIHandle);
     cOCIStmt = rb_define_class_under(cOCI8, "Cursor", cOCIHandle);
 #endif
-    cOCIStmt = oci8_define_class_under(cOCI8, "Cursor", &oci8_stmt_vtable);
+    cOCIStmt = oci8_define_class_under(cOCI8, "Cursor", &oci8_stmt_data_type, oci8_stmt_alloc);
 
     rb_define_private_method(cOCIStmt, "__initialize", oci8_stmt_initialize, 2);
     rb_define_private_method(cOCIStmt, "__define", oci8_define_by_pos, 2);
@@ -379,5 +416,5 @@ void Init_oci8_stmt(VALUE cOCI8)
     rb_define_private_method(cOCIStmt, "__paramGet", oci8_stmt_get_param, 1);
     rb_define_method(cOCIStmt, "rowid", oci8_stmt_get_rowid, 0);
 
-    oci8_define_bind_class("Cursor", &bind_stmt_vtable);
+    oci8_define_bind_class("Cursor", &bind_stmt_data_type, bind_stmt_alloc);
 }