ruby-oci8 2.2.3 → 2.2.12

data/ext/oci8/hook_funcs.c

@@ -2,29 +2,69 @@
 /*
  * hook.c
  *
- * Copyright (C) 2015 Kubo Takehiro <kubo@jiubao.org>
+ * Copyright (C) 2015-2018 Kubo Takehiro <kubo@jiubao.org>
  */
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define WINDOWS
+#include <winsock2.h>
+#endif
 #include "oci8.h"
 #include "plthook.h"
-#ifndef WIN32
+#ifdef __CYGWIN__
+#undef boolean /* boolean defined in oratypes.h coflicts with that in windows.h */
+#define stricmp strcasecmp
+#define strnicmp strncasecmp
+#endif
+#ifdef WINDOWS
+#include <windows.h>
+#include <mstcpip.h>
+#include <tlhelp32.h>
+#else
 #include <unistd.h>
 #include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <dlfcn.h>
 #endif
 
-#define DEBUG_HOOK_FUNCS 1
-
-#ifdef WIN32
+#ifdef WINDOWS
 static CRITICAL_SECTION lock;
 #define LOCK(lock) EnterCriticalSection(lock)
 #define UNLOCK(lock) LeaveCriticalSection(lock)
+typedef int socklen_t;
 #else
 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 #define LOCK(lock) pthread_mutex_lock(lock)
 #define UNLOCK(lock) pthread_mutex_unlock(lock)
 #define SOCKET int
 #define INVALID_SOCKET (-1)
+#define WSAAPI
+#endif
+
+#if defined(__APPLE__) && defined(TCP_KEEPALIVE) /* macOS */
+#define USE_TCP_KEEPALIVE
+#define SUPPORT_TCP_KEEPALIVE_TIME
+#elif defined(__sun) && defined(TCP_KEEPALIVE_THRESHOLD) /* Solaris */
+#define USE_TCP_KEEPALIVE_THRESHOLD
+#define SUPPORT_TCP_KEEPALIVE_TIME
+#elif defined(TCP_KEEPIDLE) /* Linux, etc */
+#define USE_TCP_KEEPIDLE
+#define SUPPORT_TCP_KEEPALIVE_TIME
+#elif defined(WINDOWS)
+#define SUPPORT_TCP_KEEPALIVE_TIME
 #endif
 
+int oci8_cancel_read_at_exit = 0;
+
+#ifdef SUPPORT_TCP_KEEPALIVE_TIME
+int oci8_tcp_keepalive_time = 0;
+static int WSAAPI hook_setsockopt(SOCKET sockfd, int level, int optname, const void *optval, socklen_t optlen);
+#else
+int oci8_tcp_keepalive_time = -1;
+#endif
+
+static char hook_errmsg[512];
+
 typedef struct {
     const char *func_name;
     void *func_addr;
@@ -60,62 +100,56 @@ static void socket_entry_clear(socket_entry_t *entry)
     UNLOCK(&lock);
 }
 
-static int replace_functions(const char * const *files, hook_func_entry_t *functions)
+static int replace_functions(void *addr, const char *file, hook_func_entry_t *functions)
 {
+    plthook_t *ph;
     int i;
+    int rv = 0;
 
-    for (i = 0; files[i] != NULL; i++) {
-        const char *file = files[i];
-        plthook_t *ph;
-        if (plthook_open(&ph, file) == 0) {
-            int j;
-            int rv = 0;
-
-            /* install hooks */
-            for (j = 0; functions[j].func_name != NULL ; j++) {
-                hook_func_entry_t *function = &functions[j];
-                rv = plthook_replace(ph, function->func_name, function->func_addr, &function->old_func_addr);
-                if (rv != 0) {
-                    while (--j >= 0) {
-                        /*restore hooked fuction address */
-                        plthook_replace(ph, functions[j].func_name, functions[j].old_func_addr, NULL);
-                    }
-                    plthook_close(ph);
-                    rb_raise(rb_eRuntimeError, "Could not replace function %s in %s", function->func_name, file);
-                }
+    if (plthook_open_by_address(&ph, addr) != 0) {
+        strncpy(hook_errmsg, plthook_error(), sizeof(hook_errmsg) - 1);
+        hook_errmsg[sizeof(hook_errmsg) - 1] = '\0';
+        return -1;
+    }
+
+    /* install hooks */
+    for (i = 0; functions[i].func_name != NULL ; i++) {
+        hook_func_entry_t *function = &functions[i];
+        rv = plthook_replace(ph, function->func_name, function->func_addr, &function->old_func_addr);
+        if (rv != 0) {
+            strncpy(hook_errmsg, plthook_error(), sizeof(hook_errmsg) - 1);
+            hook_errmsg[sizeof(hook_errmsg) - 1] = '\0';
+            while (--i >= 0) {
+                /*restore hooked fuction address */
+                plthook_replace(ph, functions[i].func_name, functions[i].old_func_addr, NULL);
             }
-            plthook_close(ph);
-            return 0;
+            snprintf(hook_errmsg, sizeof(hook_errmsg), "Could not replace function %s in %s", function->func_name, file);
+            break;
         }
     }
-    return -1;
+    plthook_close(ph);
+    return rv;
 }
 
-#ifdef WIN32
+#ifdef WINDOWS
+
+#ifndef _MSC_VER
+/* setsockopt() in ws2_32.dll */
+#define setsockopt rboci_setsockopt
+typedef int (WSAAPI *setsockopt_t)(SOCKET, int, int, const void *, int);
+static setsockopt_t setsockopt;
+#endif
+
+/* system-wide keepalive interval */
+static DWORD keepalive_interval;
 
 static int locK_is_initialized;
 
 static int WSAAPI hook_WSARecv(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
 
-static const char * const tcp_func_files[] = {
-    /* full client */
-    "orantcp12.dll",
-    "orantcp11.dll",
-    "orantcp10.dll",
-    "orantcp9.dll",
-    /* instant client basic */
-    "oraociei12.dll",
-    "oraociei11.dll",
-    "oraociei10.dll",
-    /* instant client basic lite */
-    "oraociicus12.dll",
-    "oraociicus11.dll",
-    "oraociicus10.dll",
-    NULL,
-};
-
 static hook_func_entry_t tcp_functions[] = {
     {"WSARecv", (void*)hook_WSARecv, NULL},
+    {"setsockopt", (void*)hook_setsockopt, NULL},
     {NULL, NULL, NULL},
 };
 
@@ -123,22 +157,112 @@ static hook_func_entry_t tcp_functions[] = {
 static int WSAAPI hook_WSARecv(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 {
     socket_entry_t entry;
+    int enable_cancel = oci8_cancel_read_at_exit;
     int rv;
 
-    socket_entry_set(&entry, s);
+    if (enable_cancel > 0) {
+        socket_entry_set(&entry, s);
+    }
     rv = WSARecv(s, lpBuffers, dwBufferCount, lpNumberOfBytesRecvd, lpFlags, lpOverlapped, lpCompletionRoutine);
-    socket_entry_clear(&entry);
+    if (enable_cancel > 0) {
+        socket_entry_clear(&entry);
+    }
     return rv;
 }
 
+static int is_target_dll(MODULEENTRY32 *me)
+{
+    static const char *basenames[] = {
+        "orantcp", // ORACLE_HOME-based client
+        "oraociei", // instant client basic
+        "oraociicus", // instant client basic lite
+        NULL,
+    };
+    const char **basename = basenames;
+    while (*basename != NULL) {
+        if (strnicmp(me->szModule, *basename, strlen(*basename)) == 0) {
+            break;
+        }
+        basename++;
+    }
+    if (*basename == NULL) {
+        return 0;
+    }
+    // basename{zero_or_more_digits}.dll
+    const char *p = me->szModule + strlen(*basename);
+    while ('0' <= *p && *p <= '9') {
+        p++;
+    }
+    if (stricmp(p, ".dll") != 0) {
+        return 0;
+    }
+    if (GetProcAddress((HMODULE)me->modBaseAddr, "nttini") == NULL) {
+        return 0;
+    }
+    return 1;
+}
+
 void oci8_install_hook_functions()
 {
+    static int hook_functions_installed = 0;
+    HKEY hKey;
+    DWORD type;
+    DWORD data;
+    DWORD cbData = sizeof(data);
+    const char *reg_key = "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters";
+    HANDLE hSnapshot;
+    MODULEENTRY32 me;
+    BOOL module_found = FALSE;
+
+    if (hook_functions_installed) {
+        return;
+    }
+
     InitializeCriticalSectionAndSpinCount(&lock, 5000);
     locK_is_initialized = 1;
 
-    if (replace_functions(tcp_func_files, tcp_functions) != 0) {
+#ifndef _MSC_VER
+    /* Get setsockopt in ws2_32.dll.
+     * setsockopt used by mingw compiler isn't same with that in ws2_32.dll.
+     */
+    setsockopt = (setsockopt_t)GetProcAddress(GetModuleHandleA("WS2_32.DLL"), "setsockopt");
+    if (setsockopt == NULL){
+        rb_raise(rb_eRuntimeError, "setsockopt isn't found in WS2_32.DLL");
+    }
+#endif
+
+    /* Get system-wide keepalive interval parameter.
+     *  https://technet.microsoft.com/en-us/library/cc957548.aspx
+     */
+    if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, reg_key, 0, KEY_QUERY_VALUE, &hKey) != 0) {
+        rb_raise(rb_eRuntimeError, "failed to open the registry key HKLM\\%s", reg_key);
+    }
+    keepalive_interval = 1000; /* default value when the following entry isn't found. */
+    if (RegQueryValueEx(hKey, "KeepAliveInterval", NULL, &type, (LPBYTE)&data, &cbData) == 0) {
+        if (type == REG_DWORD) {
+            keepalive_interval = data;
+        }
+    }
+    RegCloseKey(hKey);
+
+    hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetCurrentProcessId());
+    me.dwSize = sizeof(me);
+    if (Module32First(hSnapshot, &me)) {
+        do {
+            if (is_target_dll(&me)) {
+                module_found = TRUE;
+                if (replace_functions(me.modBaseAddr, me.szExePath, tcp_functions) != 0) {
+                    CloseHandle(hSnapshot);
+                    rb_raise(rb_eRuntimeError, "Hook error: %s", hook_errmsg);
+                }
+            }
+        } while (Module32Next(hSnapshot, &me));
+    }
+    CloseHandle(hSnapshot);
+    if (!module_found) {
         rb_raise(rb_eRuntimeError, "No DLL is found to hook.");
     }
+    hook_functions_installed = 1;
 }
 
 static void shutdown_socket(socket_entry_t *entry)
@@ -160,35 +284,89 @@ static ssize_t hook_read(int fd, void *buf, size_t count);
 #define SO_EXT "so"
 #endif
 
-static const char * const files[] = {
-    "libclntsh." SO_EXT ".12.1",
-    "libclntsh." SO_EXT ".11.1",
-    "libclntsh." SO_EXT ".10.1",
-    "libclntsh." SO_EXT ".9.0",
-    NULL,
-};
-
 static hook_func_entry_t functions[] = {
     {"read", (void*)hook_read, NULL},
+#ifdef SUPPORT_TCP_KEEPALIVE_TIME
+    {"setsockopt", (void*)hook_setsockopt, NULL},
+#endif
     {NULL, NULL, NULL},
 };
 
 static ssize_t hook_read(int fd, void *buf, size_t count)
 {
     socket_entry_t entry;
+    int enable_cancel = oci8_cancel_read_at_exit;
     ssize_t rv;
 
-    socket_entry_set(&entry, fd);
+    if (enable_cancel > 0) {
+        socket_entry_set(&entry, fd);
+    }
     rv = read(fd, buf, count);
-    socket_entry_clear(&entry);
+    if (enable_cancel > 0) {
+        socket_entry_clear(&entry);
+    }
     return rv;
 }
 
+static void *ocifunc_addr(void *dlsym_handle, const char **file)
+{
+    void *addr = dlsym(dlsym_handle, "OCIEnvCreate");
+    Dl_info dli;
+
+    if (addr == NULL) {
+        return NULL;
+    }
+    if (dladdr(addr, &dli) == 0) {
+        return NULL;
+    }
+    if (strstr(dli.dli_fname, "/libclntsh." SO_EXT) == NULL) {
+        return NULL;
+    }
+    *file = dli.dli_fname;
+    return addr;
+}
+
+#ifdef __linux__
+#include <link.h>
+static void *ocifunc_addr_linux(const char **file)
+{
+    struct link_map *lm;
+    for (lm = _r_debug.r_map; lm != NULL; lm = lm->l_next) {
+        if (strstr(lm->l_name, "/libclntsh." SO_EXT) != NULL) {
+            *file = lm->l_name;
+            return (void*)lm->l_addr;
+        }
+    }
+    return NULL;
+}
+#endif
+
 void oci8_install_hook_functions(void)
 {
-    if (replace_functions(files, functions) != 0) {
+    static int hook_functions_installed = 0;
+    void *addr;
+    const char *file;
+
+    if (hook_functions_installed) {
+        return;
+    }
+    addr = ocifunc_addr(RTLD_DEFAULT, &file);
+    if (addr == NULL) {
+        /* OCI symbols may be hooked by LD_PRELOAD. */
+        addr = ocifunc_addr(RTLD_NEXT, &file);
+    }
+#ifdef __linux__
+    if (addr == NULL) {
+        addr = ocifunc_addr_linux(&file);
+    }
+#endif
+    if (addr == NULL) {
         rb_raise(rb_eRuntimeError, "No shared library is found to hook.");
     }
+    if (replace_functions(addr, file, functions) != 0) {
+        rb_raise(rb_eRuntimeError, "Hook error: %s", hook_errmsg);
+    }
+    hook_functions_installed = 1;
 }
 
 static void shutdown_socket(socket_entry_t *entry)
@@ -197,11 +375,46 @@ static void shutdown_socket(socket_entry_t *entry)
 }
 #endif
 
+#ifdef SUPPORT_TCP_KEEPALIVE_TIME
+static int WSAAPI hook_setsockopt(SOCKET sockfd, int level, int optname, const void *optval, socklen_t optlen)
+{
+    int rv = setsockopt(sockfd, level, optname, optval, optlen);
+
+    if (rv == 0 && level == SOL_SOCKET && optname == SO_KEEPALIVE
+        && optlen == sizeof(int) && *(const int*)optval != 0) {
+        /* If Oracle client libraries enables keepalive by (ENABLE=BROKEN),
+         * set per-connection keepalive socket options to overwrite
+         * system-wide setting.
+         */
+        if (oci8_tcp_keepalive_time > 0) {
+#if defined(USE_TCP_KEEPALIVE) /* macOS */
+            setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE, &oci8_tcp_keepalive_time, sizeof(int));
+#elif defined(USE_TCP_KEEPALIVE_THRESHOLD) /* Solaris */
+            unsigned int millisec = oci8_tcp_keepalive_time * 1000;
+            setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, &millisec, sizeof(millisec));
+#elif defined(USE_TCP_KEEPIDLE) /* Linux, etc */
+            setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE, &oci8_tcp_keepalive_time, sizeof(int));
+#elif defined(WINDOWS)
+            struct tcp_keepalive vals;
+            DWORD dummy;
+
+            vals.onoff = 1;
+            vals.keepalivetime = oci8_tcp_keepalive_time * 1000;
+            vals.keepaliveinterval = keepalive_interval;
+            WSAIoctl(sockfd, SIO_KEEPALIVE_VALS, &vals, sizeof(vals), NULL, 0,
+                     &dummy, NULL, NULL);
+#endif
+        }
+    }
+    return rv;
+}
+#endif
+
 void oci8_shutdown_sockets(void)
 {
     socket_entry_t *entry;
 
-#ifdef WIN32
+#ifdef WINDOWS
     if (!locK_is_initialized) {
         return;
     }

data/ext/oci8/lob.c

@@ -26,8 +26,6 @@ static VALUE seek_end;
 
 enum state {
     S_NO_OPEN_CLOSE,
-    S_OPEN,
-    S_CLOSE,
     S_BFILE_CLOSE,
     S_BFILE_OPEN,
 };
@@ -266,28 +264,6 @@ static ub8 oci8_lob_get_length(oci8_lob_t *lob)
     return len;
 }
 
-static void lob_open(oci8_lob_t *lob)
-{
-    if (lob->state == S_CLOSE) {
-        oci8_svcctx_t *svcctx = check_svcctx(lob);
-
-        chker2(OCILobOpen_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, lob->base.hp.lob, OCI_DEFAULT),
-               &svcctx->base);
-        lob->state = S_OPEN;
-    }
-}
-
-static void lob_close(oci8_lob_t *lob)
-{
-    if (lob->state == S_OPEN) {
-        oci8_svcctx_t *svcctx = check_svcctx(lob);
-
-        chker2(OCILobClose_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, lob->base.hp.lob),
-               &svcctx->base);
-        lob->state = S_CLOSE;
-    }
-}
-
 static void bfile_close(oci8_lob_t *lob)
 {
     if (lob->state == S_BFILE_OPEN) {
@@ -368,7 +344,6 @@ static void bfile_close(oci8_lob_t *lob)
 static VALUE oci8_lob_close(VALUE self)
 {
     oci8_lob_t *lob = TO_LOB(self);
-    lob_close(lob);
     oci8_base_free(&lob->base);
     return self;
 }
@@ -591,7 +566,6 @@ static VALUE oci8_lob_truncate(VALUE self, VALUE len)
     oci8_lob_t *lob = TO_LOB(self);
     oci8_svcctx_t *svcctx = check_svcctx(lob);
 
-    lob_open(lob);
     chker2(OCILobTrim2_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, lob->base.hp.lob, NUM2ULL(len)),
            &svcctx->base);
     return self;
@@ -665,10 +639,9 @@ static VALUE oci8_lob_read(int argc, VALUE *argv, VALUE self)
 {
     oci8_lob_t *lob = TO_LOB(self);
     oci8_svcctx_t *svcctx = check_svcctx(lob);
-    ub8 lob_length;
-    ub8 read_len;
     ub8 pos = lob->pos;
-    long strbufsiz;
+    long strbufsiz = 512;
+    ub8 sz;
     ub8 byte_amt;
     ub8 char_amt;
     sword rv;
@@ -678,36 +651,21 @@ static VALUE oci8_lob_read(int argc, VALUE *argv, VALUE self)
     ub1 piece = OCI_FIRST_PIECE;
 
     rb_scan_args(argc, argv, "01", &size);
-    lob_length = oci8_lob_get_length(lob);
-    if (lob_length == 0 && NIL_P(size)) {
-        return rb_usascii_str_new("", 0);
-    }
-    if (lob_length <= pos) /* EOF */
-        return Qnil;
     if (NIL_P(size)) {
-        read_len = lob_length - pos;
+        sz = UB4MAXVAL;
     } else {
-        ub8 sz = NUM2ULL(size);
-        read_len = MIN(sz, lob_length - pos);
+        sz = NUM2ULL(size);
+    }
+    if (lob->state == S_BFILE_CLOSE) {
+        open_bfile(svcctx, lob, errhp);
     }
+read_more_data:
     if (lob->lobtype == OCI_TEMP_CLOB) {
         byte_amt = 0;
-        char_amt = read_len;
-        if (oci8_nls_ratio == 1) {
-            strbufsiz = MIN(read_len, ULONG_MAX);
-        } else {
-            strbufsiz = MIN(read_len + read_len / 8, ULONG_MAX);
-        }
-        if (strbufsiz <= 10) {
-            strbufsiz = 10;
-        }
+        char_amt = sz;
     } else {
-        byte_amt = read_len;
+        byte_amt = sz;
         char_amt = 0;
-        strbufsiz = MIN(read_len, ULONG_MAX);
-    }
-    if (lob->state == S_BFILE_CLOSE) {
-        open_bfile(svcctx, lob, errhp);
     }
     do {
         VALUE strbuf = rb_str_buf_new(strbufsiz);
@@ -737,23 +695,30 @@ static VALUE oci8_lob_read(int argc, VALUE *argv, VALUE self)
         }
         rb_str_set_len(strbuf, byte_amt);
         rb_ary_push(v, strbuf);
+        if (strbufsiz < 128 * 1024 * 1024) {
+            strbufsiz *= 2;
+        }
     } while (rv == OCI_NEED_DATA);
 
-    if (pos >= lob_length) {
-        lob_close(lob);
-        bfile_close(lob);
+    if (NIL_P(size) && pos - lob->pos == sz) {
+        lob->pos = pos;
+        piece = OCI_FIRST_PIECE;
+        goto read_more_data;
     }
     lob->pos = pos;
     switch (RARRAY_LEN(v)) {
     case 0:
-        return Qnil;
+        if (NIL_P(size) && pos == 0) {
+            return rb_usascii_str_new("", 0);
+        } else {
+            return Qnil;
+        }
     case 1:
         v = RARRAY_AREF(v, 0);
         break;
     default:
         v = rb_ary_join(v, Qnil);
     }
-    OBJ_TAINT(v);
     if (lob->lobtype == OCI_TEMP_CLOB) {
         /* set encoding */
         rb_enc_associate(v, oci8_encoding);
@@ -781,7 +746,6 @@ static VALUE oci8_lob_write(VALUE self, VALUE data)
     ub8 byte_amt;
     ub8 char_amt;
 
-    lob_open(lob);
     if (TYPE(data) != T_STRING) {
         str = rb_obj_as_string(data);
     } else {
@@ -801,48 +765,40 @@ static VALUE oci8_lob_write(VALUE self, VALUE data)
     RB_GC_GUARD(str);
     if (lob->lobtype == OCI_TEMP_CLOB) {
         lob->pos += char_amt;
-        return UINT2NUM(char_amt);
+        return ULL2NUM(char_amt);
     } else {
         lob->pos += byte_amt;
-        return UINT2NUM(byte_amt);
+        return ULL2NUM(byte_amt);
     }
 }
 
 /*
- *  @deprecated I'm not sure that this is what the name indicates.
+ *  @deprecated LOB#sync had not worked by mistake. Do nothing now.
  *  @private
  */
 static VALUE oci8_lob_get_sync(VALUE self)
 {
-    oci8_lob_t *lob = TO_LOB(self);
-    return (lob->state == S_NO_OPEN_CLOSE) ? Qtrue : Qfalse;
+    rb_warning("LOB#sync had not worked by mistake. Do nothing now.");
+    return Qfalse;
 }
 
 /*
- *  @deprecated I'm not sure that this is what the name indicates.
+ *  @deprecated LOB#sync had not worked by mistake. Do nothing now.
  *  @private
  */
 static VALUE oci8_lob_set_sync(VALUE self, VALUE b)
 {
-    oci8_lob_t *lob = TO_LOB(self);
-    if (RTEST(b)) {
-        lob_close(lob);
-        lob->state = S_NO_OPEN_CLOSE;
-    } else {
-        if (lob->state == S_NO_OPEN_CLOSE)
-            lob->state = S_CLOSE;
-    }
+    rb_warning("LOB#sync had not worked by mistake. Do nothing now.");
     return b;
 }
 
 /*
- *  @deprecated I'm not sure that this is what the name indicates.
+ *  @deprecated LOB#flush had not worked by mistake. Do nothing now.
  *  @private
  */
 static VALUE oci8_lob_flush(VALUE self)
 {
-    oci8_lob_t *lob = TO_LOB(self);
-    lob_close(lob);
+    rb_warning("LOB#flush had not worked by mistake. Do nothing now.");
     return self;
 }
 

data/ext/oci8/metadata.c

@@ -195,7 +195,7 @@ VALUE oci8_do_describe(VALUE self, void *objptr, ub4 objlen, ub1 objtype, VALUE
 static VALUE oci8_describe(VALUE self, VALUE name, VALUE klass, VALUE check_public)
 {
     char *str;
-    size_t idx, len;
+    int idx, len;
     VALUE metadata;
     VALUE obj_link = Qnil;
 
@@ -204,7 +204,7 @@ static VALUE oci8_describe(VALUE self, VALUE name, VALUE klass, VALUE check_publ
         rb_raise(rb_eArgError, "empty string is set.");
     }
     str = RSTRING_PTR(name);
-    len = RSTRING_LEN(name);
+    len = RSTRING_LENINT(name);
     for (idx = 0; idx < len; idx++) {
         if (str[idx] == '@') {
             obj_link = rb_enc_str_new(str + idx + 1, len - idx - 1, oci8_encoding);