ruby-oci8 2.2.0.2 → 2.2.12

data/ext/oci8/extconf.rb

@@ -25,77 +25,44 @@ $CFLAGS += oraconf.cflags
 saved_libs = $libs
 $libs += oraconf.libs
 
-oci_actual_client_version = 0x08000000
-funcs = {}
-YAML.load(open(File.dirname(__FILE__) + '/apiwrap.yml')).each do |key, val|
-  key = key[0..-4] if key[-3..-1] == '_nb'
-  ver = val[:version]
-  ver_major = (ver / 100)
-  ver_minor = (ver / 10) % 10
-  ver_update = ver % 10
-  ver = ((ver_major << 24) | (ver_minor << 20) | (ver_update << 12))
-  funcs[ver] ||= []
-  funcs[ver] << key
-end
-
 saved_defs = $defs.clone
-funcs.keys.sort.each do |version|
-  next if version == 0x08000000
-  verstr = format('%d.%d.%d', ((version >> 24) & 0xFF), ((version >> 20) & 0xF), ((version >> 12) & 0xFF))
-  puts "checking for Oracle #{verstr} API - start"
-  result = catch :result do
-    funcs[version].sort.each do |func|
-      unless have_func(func)
-        throw :result, "fail"
-      end
-    end
-    oci_actual_client_version = version
-    "pass"
+fmt = "%s"
+def fmt.%(x)
+  x ? super : "failed"
+end
+oci_major_version = checking_for 'OCI_MAJOR_VERSION in oci.h', fmt do
+  try_constant('OCI_MAJOR_VERSION', 'oci.h')
+end
+if oci_major_version
+  oci_minor_version = checking_for 'OCI_MINOR_VERSION in oci.h', fmt do
+    try_constant('OCI_MINOR_VERSION', 'oci.h')
+  end
+else
+  if have_func('OCILobGetLength2')
+    oci_major_version = 10
+    oci_minor_version = 1
+  elsif have_func('OCIStmtPrepare2')
+    raise "Ruby-oci8 #{OCI8::VERSION} doesn't support Oracle 9iR2. Use ruby-oci8 2.1.x instead."
+  elsif have_func('OCILogon2')
+    raise "Ruby-oci8 #{OCI8::VERSION} doesn't support Oracle 9iR1. Use ruby-oci8 2.1.x instead."
+  elsif have_func('OCIEnvCreate')
+    raise "Ruby-oci8 #{OCI8::VERSION} doesn't support Oracle 8i. Use ruby-oci8 2.0.x instead."
+  else
+    raise "Ruby-oci8 #{OCI8::VERSION} doesn't support Oracle 8. Use ruby-oci8 2.0.x instead."
   end
-  puts "checking for Oracle #{verstr} API - #{result}"
-  break if result == 'fail'
 end
 $defs = saved_defs
 
-have_type('oratext', 'ociap.h')
-have_type('OCIDateTime*', 'ociap.h')
-have_type('OCIInterval*', 'ociap.h')
-have_type('OCICallbackLobRead2', 'ociap.h')
-have_type('OCICallbackLobWrite2', 'ociap.h')
-have_type('OCIAdmin*', 'ociap.h')
-have_type('OCIAuthInfo*', 'ociap.h')
-have_type('OCIMsg*', 'ociap.h')
-have_type('OCICPool*', 'ociap.h')
-
 if with_config('oracle-version')
-  oci_client_version = OCI8::OracleVersion.new(with_config('oracle-version')).to_i
+  oraver = OCI8::OracleVersion.new(with_config('oracle-version'))
 else
-  oci_client_version = oci_actual_client_version
+  oraver = OCI8::OracleVersion.new(oci_major_version, oci_minor_version)
 end
-$defs << "-DORACLE_CLIENT_VERSION=#{format('0x%08x', oci_client_version)}"
+$defs << "-DORACLE_CLIENT_VERSION=#{format('0x%08x', oraver.to_i)}"
 
 if with_config('runtime-check')
   $defs << "-DRUNTIME_API_CHECK=1"
   $libs = saved_libs
-else
-  oraver = OCI8::OracleVersion.new(oci_client_version)
-  if oraver < OCI8::OracleVersion.new(10)
-    case "#{oraver.major}.#{oraver.minor}"
-    when "8.0"
-      ora_name = "Oracle 8"
-      oci8_ver = "2.0.x"
-    when "8.1"
-      ora_name = "Oracle 8i"
-      oci8_ver = "2.0.x"
-    when "9.1"
-      ora_name = "Oracle 9iR1"
-      oci8_ver = "2.1.x"
-    when "9.2"
-      ora_name = "Oracle 9iR2"
-      oci8_ver = "2.1.x"
-    end
-    raise "Ruby-oci8 #{OCI8::VERSION} doesn't support #{ora_name}. Use ruby-oci8 #{oci8_ver} instead."
-  end
 end
 
 $objs = ["oci8lib.o", "env.o", "error.o", "oci8.o", "ocihandle.o",
@@ -105,7 +72,7 @@ $objs = ["oci8lib.o", "env.o", "error.o", "oci8.o", "ocihandle.o",
          "ocinumber.o", "ocidatetime.o", "object.o", "apiwrap.o",
          "encoding.o", "oranumber_util.o", "thread_util.o", "util.o"]
 
-if RUBY_PLATFORM =~ /mswin32|cygwin|mingw32|bccwin32/
+if RUBY_PLATFORM =~ /mswin32|cygwin|mingw/
   $defs << "-DUSE_WIN32_C"
   $objs << "win32.o"
 end
@@ -172,6 +139,8 @@ when 'rbx'
   so_basename += 'rbx'
 when 'jruby'
   raise "Ruby-oci8 doesn't support jruby because its C extension support is in development in jruby 1.6 and deprecated in jruby 1.7."
+when 'truffleruby'
+  so_basename += 'truffleruby'
 else
   raise 'unsupported ruby engine: ' + RUBY_ENGINE
 end
@@ -179,19 +148,22 @@ end
 print "checking for plthook... "
 STDOUT.flush
 case RUBY_PLATFORM
-when /mswin32|cygwin|mingw32|bccwin32/
+when /mswin32|cygwin|mingw/
   plthook_src = "plthook_win32.c"
 when /darwin/
   plthook_src = "plthook_osx.c"
 else
   plthook_src = "plthook_elf.c"
 end
-if xsystem(cc_command("").gsub(CONFTEST_C, File.dirname(__FILE__) + "/" + plthook_src))
-  File.delete(plthook_src.gsub(/\.c$/, '.' + RbConfig::CONFIG["OBJEXT"]))
+FileUtils.copy(File.dirname(__FILE__) + "/" + plthook_src, CONFTEST_C)
+if xsystem(cc_command(""))
+  FileUtils.rm_f("#{CONFTEST}.#{$OBJEXT}")
   puts plthook_src
   $objs << plthook_src.gsub(/\.c$/, '.o')
   $objs << "hook_funcs.o"
   $defs << "-DHAVE_PLTHOOK"
+  have_library('dbghelp', 'ImageDirectoryEntryToData', ['windows.h', 'dbghelp.h']) if RUBY_PLATFORM =~ /cygwin/
+  $libs += ' -lws2_32' if RUBY_PLATFORM =~ /cygwin/
 else
   puts "no"
 end

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;
     }