ruby-oci8 2.2.3 → 2.2.4

data/ext/oci8/hook_funcs.c

@@ -9,14 +9,15 @@
 #ifndef WIN32
 #include <unistd.h>
 #include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
 #endif
 
-#define DEBUG_HOOK_FUNCS 1
-
 #ifdef WIN32
 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)
@@ -25,6 +26,29 @@ static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 #define INVALID_SOCKET (-1)
 #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(WIN32) /* 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 hook_setsockopt(SOCKET sockfd, int level, int optname, const void *optval, socklen_t optlen);
+#else
+int oci8_tcp_keepalive_time = -1;
+#endif
+
+
 typedef struct {
     const char *func_name;
     void *func_addr;
@@ -93,6 +117,16 @@ static int replace_functions(const char * const *files, hook_func_entry_t *funct
 
 #ifdef WIN32
 
+#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);
@@ -116,6 +150,7 @@ static const char * const tcp_func_files[] = {
 
 static hook_func_entry_t tcp_functions[] = {
     {"WSARecv", (void*)hook_WSARecv, NULL},
+    {"setsockopt", (void*)hook_setsockopt, NULL},
     {NULL, NULL, NULL},
 };
 
@@ -123,22 +158,63 @@ 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;
 }
 
 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";
+
+    if (hook_functions_installed) {
+        return;
+    }
+
     InitializeCriticalSectionAndSpinCount(&lock, 5000);
     locK_is_initialized = 1;
 
+#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);
+
     if (replace_functions(tcp_func_files, tcp_functions) != 0) {
         rb_raise(rb_eRuntimeError, "No DLL is found to hook.");
     }
+    hook_functions_installed = 1;
 }
 
 static void shutdown_socket(socket_entry_t *entry)
@@ -170,25 +246,39 @@ static const char * const files[] = {
 
 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;
 }
 
 void oci8_install_hook_functions(void)
 {
+    static int hook_functions_installed = 0;
+
+    if (hook_functions_installed) {
+        return;
+    }
     if (replace_functions(files, functions) != 0) {
         rb_raise(rb_eRuntimeError, "No shared library is found to hook.");
     }
+    hook_functions_installed = 1;
 }
 
 static void shutdown_socket(socket_entry_t *entry)
@@ -197,6 +287,41 @@ static void shutdown_socket(socket_entry_t *entry)
 }
 #endif
 
+#ifdef SUPPORT_TCP_KEEPALIVE_TIME
+static int 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(WIN32) /* 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;

data/ext/oci8/oci8.c

@@ -286,7 +286,7 @@ static VALUE oci8_s_oracle_client_vernum(VALUE klass)
 /*
  * @overload OCI8.__get_prop(key)
  *
- *  @param [Fixnum] key    1, 2 or 3
+ *  @param [Integer] key   1, 2 or 3
  *  @return [Object]       depends on +key+.
  *  @private
  */
@@ -306,16 +306,13 @@ static VALUE oci8_s_get_prop(VALUE klass, VALUE key)
 /*
  * @overload OCI8.__set_prop(key, value)
  *
- *  @param [Fixnum] key    1, 2 or 3
+ *  @param [Integer] key   1, 2 or 3
  *  @param [Object] value  depends on +key+.
  *
  *  @private
  */
 static VALUE oci8_s_set_prop(VALUE klass, VALUE key, VALUE val)
 {
-#ifdef HAVE_PLTHOOK
-    static int hook_functions_installed = 0;
-#endif
     switch (NUM2INT(key)) {
     case 1:
         oci8_float_conversion_type_is_ruby = RTEST(val) ? 1 : 0;
@@ -331,13 +328,21 @@ static VALUE oci8_s_set_prop(VALUE klass, VALUE key, VALUE val)
         oci8_env_mode = NUM2UINT(val);
         break;
     case 3:
+        if (oci8_cancel_read_at_exit == -1) {
+            rb_raise(rb_eNotImpError, "OCI8.properties[:cancel_read_at_exit] isn't available.");
+        }
 #ifdef HAVE_PLTHOOK
-        if (!hook_functions_installed) {
-            oci8_install_hook_functions();
-            hook_functions_installed = 1;
+        oci8_install_hook_functions();
+        oci8_cancel_read_at_exit = RTEST(val) ? 1 : 0;
+#endif
+        break;
+    case 4:
+        if (oci8_tcp_keepalive_time == -1) {
+            rb_raise(rb_eNotImpError, "OCI8.properties[:tcp_keepalive_time] isn't available.");
         }
-#else
-        rb_raise(rb_eNotImpError, ":cancel_read_at_exit isn't implemented on this machine.");
+#ifdef HAVE_PLTHOOK
+        oci8_install_hook_functions();
+        oci8_tcp_keepalive_time = NIL_P(val) ? 0 : NUM2INT(val);
 #endif
         break;
     default:
@@ -359,7 +364,7 @@ static VALUE oci8_s_set_prop(VALUE klass, VALUE key, VALUE val)
  *    # When NLS_LANG is FRENCH_FRANCE.AL32UTF8
  *    OCI8.error_message(1) # => "ORA-00001: violation de contrainte unique (%s.%s)"
  *
- *  @param [Fixnum] message_no   Oracle error message number
+ *  @param [Integer] message_no  Oracle error message number
  *  @return [String]             Oracle error message
  */
 static VALUE oci8_s_error_message(VALUE klass, VALUE msgid)
@@ -668,8 +673,8 @@ static VALUE oci8_server_attach(VALUE self, VALUE dbname, VALUE attach_mode)
  *
  *  Begins the session by the OCI function OCISessionBegin().
  *
- *  @param [Fixnum] cred
- *  @param [Fixnum] mode
+ *  @param [Integer] cred
+ *  @param [Integer] mode
  *  @private
  */
 static VALUE oci8_session_begin(VALUE self, VALUE cred, VALUE mode)

data/ext/oci8/oci8.h

@@ -340,7 +340,8 @@ typedef struct {
 } oci8_exec_sql_var_t;
 
 #define oci8_raise(err, status, stmt) oci8_do_raise(err, status, stmt, __FILE__, __LINE__)
-#define oci8_env_raise(err, status) oci8_do_env_raise(err, status, __FILE__, __LINE__)
+#define oci8_env_raise(env, status) oci8_do_env_raise(env, status, 0, __FILE__, __LINE__)
+#define oci8_env_free_and_raise(env, status) oci8_do_env_raise(env, status, 1, __FILE__, __LINE__)
 #define oci8_raise_init_error() oci8_do_raise_init_error(__FILE__, __LINE__)
 #define oci8_raise_by_msgno(msgno, default_msg) oci8_do_raise_by_msgno(msgno, default_msg, __FILE__, __LINE__)
 
@@ -406,7 +407,7 @@ void *oci8_check_typeddata(VALUE obj, const oci8_handle_data_type_t *data_type,
 extern VALUE eOCIException;
 extern VALUE eOCIBreak;
 void Init_oci8_error(void);
-NORETURN(void oci8_do_env_raise(OCIEnv *, sword status, const char *file, int line));
+NORETURN(void oci8_do_env_raise(OCIEnv *envhp, sword status, int free_envhp, const char *file, int line));
 NORETURN(void oci8_do_raise_init_error(const char *file, int line));
 sb4 oci8_get_error_code(OCIError *errhp);
 VALUE oci8_get_error_message(ub4 msgno, const char *default_msg);
@@ -514,6 +515,13 @@ void Init_oci8_win32(VALUE cOCI8);
 /* hook_funcs.c */
 void oci8_install_hook_functions(void);
 void oci8_shutdown_sockets(void);
+#ifdef HAVE_PLTHOOK
+extern int oci8_cancel_read_at_exit;
+extern int oci8_tcp_keepalive_time;
+#else
+#define oci8_cancel_read_at_exit (-1)
+#define oci8_tcp_keepalive_time (-1)
+#endif
 
 #define OCI8StringValue(v) do { \
     StringValue(v); \

data/ext/oci8/oci8lib.c

@@ -7,6 +7,10 @@
 #ifdef HAVE_RUBY_THREAD_H
 #include <ruby/thread.h>
 #endif
+#if defined(HAVE_PLTHOOK) && !defined(WIN32)
+#include <dlfcn.h>
+#include "plthook.h"
+#endif
 
 ID oci8_id_at_last_error;
 ID oci8_id_get;
@@ -67,6 +71,122 @@ static VALUE bind_base_alloc(VALUE klass)
     rb_raise(rb_eNameError, "private method `new' called for %s:Class", rb_class2name(klass));
 }
 
+#if defined(HAVE_PLTHOOK) && !defined(WIN32)
+static const char *find_libclntsh(void *handle)
+{
+    void *symaddr = dlsym(handle, "OCIEnvCreate");
+    Dl_info info;
+#ifdef __APPLE__
+    const char *basename = "libclntsh.dylib";
+#else
+    const char *basename = "libclntsh.so";
+#endif
+    const char *p;
+
+    if (symaddr == NULL) {
+        return NULL;
+    }
+    if (dladdr(symaddr, &info) == 0) {
+        return NULL;
+    }
+    if ((p = strrchr(info.dli_fname, '/')) == NULL) {
+        return NULL;
+    }
+    if (strncmp(p + 1, basename, strlen(basename)) != 0) {
+        return NULL;
+    }
+    return info.dli_fname;
+}
+
+/*
+ * Symbol prefix depends on the platform.
+ *  Linux x86_64 - no prefix
+ *  Linux x86_32 - "_"
+ *  macOS        - "@_"
+ */
+static const char *find_symbol_prefix(plthook_t *ph, size_t *len)
+{
+    unsigned int pos = 0;
+    const char *name;
+    void **addr;
+
+    while (plthook_enum(ph, &pos, &name, &addr) == 0) {
+        const char *p = strstr(name, "OCIEnvCreate");
+        if (p != NULL) {
+            *len = p - name;
+            return name;
+        }
+    }
+    return NULL;
+}
+
+/*
+ * Fix PLT entries against function interposition.
+ * See: http://www.rubydoc.info/github/kubo/ruby-oci8/file/docs/ldap-auth-and-function-interposition.md
+ */
+static void rebind_internal_symbols(void)
+{
+    const char *libfile;
+    void *handle;
+    int flags = RTLD_LAZY | RTLD_NOLOAD;
+    plthook_t *ph;
+    unsigned int pos = 0;
+    const char *name;
+    void **addr;
+    const char *prefix;
+    size_t prefix_len;
+
+#ifdef RTLD_FIRST
+    flags |= RTLD_FIRST; /* for macOS */
+#endif
+
+    libfile = find_libclntsh(RTLD_DEFAULT); /* normal case */
+    if (libfile == NULL) {
+        libfile = find_libclntsh(RTLD_NEXT); /* special case when OCIEnvCreate is hooked by LD_PRELOAD */
+    }
+    if (libfile == NULL) {
+        return;
+    }
+    handle = dlopen(libfile, flags);
+    if (handle == NULL) {
+        return;
+    }
+    if (plthook_open(&ph, libfile) != 0) {
+        dlclose(handle);
+        return;
+    }
+    prefix = find_symbol_prefix(ph, &prefix_len);
+    if (prefix == NULL) {
+        dlclose(handle);
+        plthook_close(ph);
+        return;
+    }
+    while (plthook_enum(ph, &pos, &name, &addr) == 0) {
+        void *funcaddr;
+        if (prefix_len != 0) {
+            if (strncmp(name, prefix, prefix_len) != 0) {
+                continue;
+            }
+            name += prefix_len;
+        }
+        if (strncmp(name, "OCI", 3) == 0) {
+            /* exclude functions starting with OCI not to prevent LD_PRELOAD hooking */
+            continue;
+        }
+        funcaddr = dlsym(handle, name);
+        if (funcaddr != NULL && *addr != funcaddr) {
+            /* If libclntsh.so exports and imports same functions, their
+             * PLT entries are forcedly modified to point to itself not
+             * to use functions in other libraries.
+             */
+            *addr = funcaddr;
+        }
+    }
+    plthook_close(ph);
+    dlclose(handle);
+}
+#endif
+
 #ifdef _WIN32
 __declspec(dllexport)
 #endif
@@ -74,7 +194,7 @@ void
 Init_oci8lib()
 {
     VALUE cOCI8;
-    OCIEnv *envhp;
+    OCIEnv *envhp = NULL;
     OCIError *errhp;
     sword rv;
 
@@ -106,6 +226,9 @@ Init_oci8lib()
         oracle_client_version = ORAVERNUM(major, minor, update, patch, port_update);
     }
 #endif
+#if defined(HAVE_PLTHOOK) && !defined(WIN32)
+    rebind_internal_symbols();
+#endif
 
     oci8_id_at_last_error = rb_intern("@last_error");
     oci8_id_get = rb_intern("get");
@@ -153,7 +276,11 @@ Init_oci8lib()
     /* allocate a temporary errhp to pass Init_oci_number() */
     rv = OCIEnvCreate(&envhp, oci8_env_mode, NULL, NULL, NULL, NULL, 0, NULL);
     if (rv != OCI_SUCCESS) {
-        oci8_raise_init_error();
+        if (envhp != NULL) {
+            oci8_env_free_and_raise(envhp, rv);
+        } else {
+            oci8_raise_init_error();
+        }
     }
     rv = OCIHandleAlloc(envhp, (dvoid *)&errhp, OCI_HTYPE_ERROR, 0, NULL);
     if (rv != OCI_SUCCESS)