trilogy 2.4.0 → 2.5.0

data/ext/trilogy-ruby/src/socket.c

@@ -1,5 +1,6 @@
 #include <netdb.h>
 #include <netinet/tcp.h>
+#include <netinet/in.h>
 #include <poll.h>
 #include <sys/socket.h>
 #include <sys/types.h>
@@ -65,7 +66,11 @@ static ssize_t _cb_raw_read(trilogy_sock_t *_sock, void *buf, size_t nread)
     struct trilogy_sock *sock = (struct trilogy_sock *)_sock;
     ssize_t data_read = read(sock->fd, buf, nread);
     if (data_read < 0) {
-        return (ssize_t)TRILOGY_SYSERR;
+        if (errno == EINTR || errno == EAGAIN) {
+            return (ssize_t)TRILOGY_AGAIN;
+        } else {
+            return (ssize_t)TRILOGY_SYSERR;
+        }
     }
     return data_read;
 }
@@ -75,6 +80,14 @@ static ssize_t _cb_raw_write(trilogy_sock_t *_sock, const void *buf, size_t nwri
     struct trilogy_sock *sock = (struct trilogy_sock *)_sock;
     ssize_t data_written = write(sock->fd, buf, nwrite);
     if (data_written < 0) {
+        if (errno == EINTR || errno == EAGAIN) {
+            return (ssize_t)TRILOGY_AGAIN;
+        }
+
+        if (errno == EPIPE) {
+            return (ssize_t)TRILOGY_CLOSED_CONNECTION;
+        }
+
         return (ssize_t)TRILOGY_SYSERR;
     }
     return data_written;
@@ -109,7 +122,53 @@ static int _cb_raw_close(trilogy_sock_t *_sock)
     return rc;
 }
 
-static int _cb_raw_shutdown(trilogy_sock_t *_sock) { return shutdown(trilogy_sock_fd(_sock), SHUT_RDWR); }
+static int _cb_shutdown_connect(trilogy_sock_t *_sock) {
+    (void)_sock;
+    return TRILOGY_CLOSED_CONNECTION;
+}
+static ssize_t _cb_shutdown_write(trilogy_sock_t *_sock, const void *buf, size_t nwrite) {
+    (void)_sock;
+    (void)buf;
+    (void)nwrite;
+    return TRILOGY_CLOSED_CONNECTION;
+}
+static ssize_t _cb_shutdown_read(trilogy_sock_t *_sock, void *buf, size_t nread) {
+    (void)_sock;
+    (void)buf;
+    (void)nread;
+    return TRILOGY_CLOSED_CONNECTION;
+}
+static int _cb_shutdown_wait(trilogy_sock_t *_sock, trilogy_wait_t wait) {
+    (void)_sock;
+    (void)wait;
+    return TRILOGY_OK;
+}
+static int _cb_shutdown_shutdown(trilogy_sock_t *_sock) {
+    (void)_sock;
+    return TRILOGY_OK;
+}
+
+// Shutdown will close the underlying socket fd and replace all I/O operations with stubs which perform no action.
+static int _cb_raw_shutdown(trilogy_sock_t *_sock) {
+    struct trilogy_sock *sock = (struct trilogy_sock *)_sock;
+
+    // Replace all operations with stubs which return immediately
+    sock->base.connect_cb = _cb_shutdown_connect;
+    sock->base.read_cb = _cb_shutdown_read;
+    sock->base.write_cb = _cb_shutdown_write;
+    sock->base.wait_cb = _cb_shutdown_wait;
+    sock->base.shutdown_cb = _cb_shutdown_shutdown;
+
+    // These "raw" callbacks won't attempt further operations on the socket and work correctly with fd set to -1
+    sock->base.close_cb = _cb_raw_close;
+    sock->base.fd_cb = _cb_raw_fd;
+
+    if (sock->fd != -1)
+        close(sock->fd);
+    sock->fd = -1;
+
+    return TRILOGY_OK;
+}
 
 static int set_nonblocking_fd(int sock)
 {
@@ -306,12 +365,18 @@ fail:
 
 static ssize_t ssl_io_return(struct trilogy_sock *sock, ssize_t ret)
 {
-    if (ret < 0) {
+    if (ret <= 0) {
         int rc = SSL_get_error(sock->ssl, (int)ret);
         if (rc == SSL_ERROR_WANT_WRITE || rc == SSL_ERROR_WANT_READ) {
             return (ssize_t)TRILOGY_AGAIN;
-        } else if (rc == SSL_ERROR_SYSCALL && errno != 0) {
-            return (ssize_t)TRILOGY_SYSERR;
+        } else if (rc == SSL_ERROR_SYSCALL && !ERR_peek_error()) {
+            if (errno == 0) {
+                // On OpenSSL <= 1.1.1, SSL_ERROR_SYSCALL with an errno value
+                // of 0 indicates unexpected EOF from the peer.
+                return (ssize_t)TRILOGY_CLOSED_CONNECTION;
+            } else {
+                return (ssize_t)TRILOGY_SYSERR;
+            }
         }
         return (ssize_t)TRILOGY_OPENSSL_ERR;
     }
@@ -321,6 +386,11 @@ static ssize_t ssl_io_return(struct trilogy_sock *sock, ssize_t ret)
 static ssize_t _cb_ssl_read(trilogy_sock_t *_sock, void *buf, size_t nread)
 {
     struct trilogy_sock *sock = (struct trilogy_sock *)_sock;
+
+    // This shouldn't be necessary, but protects against other libraries in the same process incorrectly leaving errors
+    // in the queue.
+    ERR_clear_error();
+
     ssize_t data_read = (ssize_t)SSL_read(sock->ssl, buf, (int)nread);
     return ssl_io_return(sock, data_read);
 }
@@ -328,6 +398,11 @@ static ssize_t _cb_ssl_read(trilogy_sock_t *_sock, void *buf, size_t nread)
 static ssize_t _cb_ssl_write(trilogy_sock_t *_sock, const void *buf, size_t nwrite)
 {
     struct trilogy_sock *sock = (struct trilogy_sock *)_sock;
+
+    // This shouldn't be necessary, but protects against other libraries in the same process incorrectly leaving errors
+    // in the queue.
+    ERR_clear_error();
+
     ssize_t data_written = (ssize_t)SSL_write(sock->ssl, buf, (int)nwrite);
     return ssl_io_return(sock, data_written);
 }
@@ -340,15 +415,9 @@ static int _cb_ssl_shutdown(trilogy_sock_t *_sock)
     // we need to close it. The OpenSSL explicitly states
     // not to call SSL_shutdown on a broken SSL socket.
     SSL_free(sock->ssl);
-    // Reset the handlers since we tore down SSL, so we
-    // fall back to the regular methods for detecting
-    // we have a closed connection and for the cleanup.
-    sock->base.read_cb = _cb_raw_read;
-    sock->base.write_cb = _cb_raw_write;
-    sock->base.shutdown_cb = _cb_raw_shutdown;
-    sock->base.close_cb = _cb_raw_close;
     sock->ssl = NULL;
 
+    // This will rewrite the handlers
     return _cb_raw_shutdown(_sock);
 }
 
@@ -356,7 +425,12 @@ static int _cb_ssl_close(trilogy_sock_t *_sock)
 {
     struct trilogy_sock *sock = (struct trilogy_sock *)_sock;
     if (sock->ssl != NULL) {
-        SSL_shutdown(sock->ssl);
+        if (SSL_in_init(sock->ssl) == 0) {
+            (void)SSL_shutdown(sock->ssl);
+            // SSL_shutdown might return WANT_WRITE or WANT_READ. Ideally we would retry but we don't want to block.
+            // It may also push an error onto the OpenSSL error queue, so clear that.
+            ERR_clear_error();
+        }
         SSL_free(sock->ssl);
         sock->ssl = NULL;
     }
@@ -537,6 +611,10 @@ int trilogy_sock_upgrade_ssl(trilogy_sock_t *_sock)
 {
     struct trilogy_sock *sock = (struct trilogy_sock *)_sock;
 
+    // This shouldn't be necessary, but protects against other libraries in the same process incorrectly leaving errors
+    // in the queue.
+    ERR_clear_error();
+
     SSL_CTX *ctx = trilogy_ssl_ctx(&sock->base.opts);
 
     if (!ctx) {
@@ -548,7 +626,7 @@ int trilogy_sock_upgrade_ssl(trilogy_sock_t *_sock)
 
     if (sock->base.opts.ssl_mode == TRILOGY_SSL_VERIFY_IDENTITY && sock->base.opts.hostname == NULL) {
         // If hostname validation is requested and no hostname provided, treat it as an error.
-#if OPENSSL_VERSION_NUMBER >= 0x1010000fL
+#ifdef SSL_F_TLS_PROCESS_SERVER_CERTIFICATE
         ERR_put_error(ERR_LIB_SSL, SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, SSL_R_CERTIFICATE_VERIFY_FAILED, NULL, 0);
 #else
         ERR_put_error(ERR_LIB_SSL, SSL_F_SSL3_GET_SERVER_CERTIFICATE, SSL_R_CERTIFICATE_VERIFY_FAILED, NULL, 0);
@@ -579,6 +657,10 @@ int trilogy_sock_upgrade_ssl(trilogy_sock_t *_sock)
         goto fail;
 
     for (;;) {
+        // This shouldn't be necessary, but protects against other libraries in the same process incorrectly leaving errors
+        // in the queue.
+        ERR_clear_error();
+
         int ret = SSL_connect(sock->ssl);
         if (ret == 1) {
 #if OPENSSL_VERSION_NUMBER < 0x1000200fL
@@ -621,28 +703,3 @@ fail:
     sock->ssl = NULL;
     return TRILOGY_OPENSSL_ERR;
 }
-
-int trilogy_sock_discard(trilogy_sock_t *_sock)
-{
-    struct trilogy_sock *sock = (struct trilogy_sock *)_sock;
-
-    if (sock->fd < 0) {
-        return TRILOGY_OK;
-    }
-
-    int null_fd = open("/dev/null", O_RDWR | O_CLOEXEC);
-    if (null_fd < 0) {
-        return TRILOGY_SYSERR;
-    }
-
-    if (dup2(null_fd, sock->fd) < 0) {
-        close(null_fd);
-        return TRILOGY_SYSERR;
-    }
-
-    if (close(null_fd) < 0) {
-        return TRILOGY_SYSERR;
-    }
-
-    return TRILOGY_OK;
-}

data/lib/trilogy/encoding.rb

@@ -0,0 +1,97 @@
+class Trilogy
+  module Encoding
+    RUBY_ENCODINGS = {
+      "big5"     => "Big5",
+      "dec8"     => nil,
+      "cp850"    => "CP850",
+      "hp8"      => nil,
+      "koi8r"    => "KOI8-R",
+      "latin1"   => "ISO-8859-1",
+      "latin2"   => "ISO-8859-2",
+      "swe7"     => nil,
+      "ascii"    => "US-ASCII",
+      "ujis"     => "eucJP-ms",
+      "sjis"     => "Shift_JIS",
+      "hebrew"   => "ISO-8859-8",
+      "tis620"   => "TIS-620",
+      "euckr"    => "EUC-KR",
+      "koi8u"    => "KOI8-R",
+      "gb2312"   => "GB2312",
+      "greek"    => "ISO-8859-7",
+      "cp1250"   => "Windows-1250",
+      "gbk"      => "GBK",
+      "latin5"   => "ISO-8859-9",
+      "armscii8" => nil,
+      "utf8"     => "UTF-8",
+      "ucs2"     => "UTF-16BE",
+      "cp866"    => "IBM866",
+      "keybcs2"  => nil,
+      "macce"    => "macCentEuro",
+      "macroman" => "macRoman",
+      "cp852"    => "CP852",
+      "latin7"   => "ISO-8859-13",
+      "utf8mb4"  => "UTF-8",
+      "cp1251"   => "Windows-1251",
+      "utf16"    => "UTF-16",
+      "cp1256"   => "Windows-1256",
+      "cp1257"   => "Windows-1257",
+      "utf32"    => "UTF-32",
+      "binary"   => "ASCII-8BIT",
+      "geostd8"  => nil,
+      "cp932"    => "Windows-31J",
+      "eucjpms"  => "eucJP-ms",
+      "utf16le"  => "UTF-16LE",
+      "gb18030"  => "GB18030",
+    }.freeze
+
+    CHARSETS = {
+      "big5"     => CHARSET_BIG5_CHINESE_CI,
+      "cp850"    => CHARSET_CP850_GENERAL_CI,
+      "koi8r"    => CHARSET_KOI8R_GENERAL_CI,
+      "latin1"   => CHARSET_LATIN1_GENERAL_CI,
+      "latin2"   => CHARSET_LATIN2_GENERAL_CI,
+      "ascii"    => CHARSET_ASCII_GENERAL_CI,
+      "ujis"     => CHARSET_UJIS_JAPANESE_CI,
+      "sjis"     => CHARSET_SJIS_JAPANESE_CI,
+      "hebrew"   => CHARSET_HEBREW_GENERAL_CI,
+      "tis620"   => CHARSET_TIS620_THAI_CI,
+      "euckr"    => CHARSET_EUCKR_KOREAN_CI,
+      "koi8u"    => CHARSET_KOI8U_GENERAL_CI,
+      "gb2312"   => CHARSET_GB2312_CHINESE_CI,
+      "greek"    => CHARSET_GREEK_GENERAL_CI,
+      "cp1250"   => CHARSET_CP1250_GENERAL_CI,
+      "gbk"      => CHARSET_GBK_CHINESE_CI,
+      "latin5"   => CHARSET_LATIN5_TURKISH_CI,
+      "utf8"     => CHARSET_UTF8_GENERAL_CI,
+      "ucs2"     => CHARSET_UCS2_GENERAL_CI,
+      "cp866"    => CHARSET_CP866_GENERAL_CI,
+      "cp932"    => CHARSET_CP932_JAPANESE_CI,
+      "eucjpms"  => CHARSET_EUCJPMS_JAPANESE_CI,
+      "utf16le"  => CHARSET_UTF16_GENERAL_CI,
+      "gb18030"  => CHARSET_GB18030_CHINESE_CI,
+      "macce"    => CHARSET_MACCE_GENERAL_CI,
+      "macroman" => CHARSET_MACROMAN_GENERAL_CI,
+      "cp852"    => CHARSET_CP852_GENERAL_CI,
+      "latin7"   => CHARSET_LATIN7_GENERAL_CI,
+      "utf8mb4"  => CHARSET_UTF8MB4_GENERAL_CI,
+      "cp1251"   => CHARSET_CP1251_GENERAL_CI,
+      "utf16"    => CHARSET_UTF16_GENERAL_CI,
+      "cp1256"   => CHARSET_CP1256_GENERAL_CI,
+      "cp1257"   => CHARSET_CP1257_GENERAL_CI,
+      "utf32"    => CHARSET_UTF32_GENERAL_CI,
+      "binary"   => CHARSET_BINARY,
+    }.freeze
+
+    def self.find(mysql_encoding)
+      unless rb_encoding = RUBY_ENCODINGS[mysql_encoding]
+        raise ArgumentError, "Unknown or unsupported encoding: #{mysql_encoding}"
+      end
+
+      ::Encoding.find(rb_encoding)
+    end
+
+    def self.charset(mysql_encoding)
+      CHARSETS[mysql_encoding]
+    end
+  end
+end

data/lib/trilogy/error.rb

@@ -0,0 +1,118 @@
+class Trilogy
+  # Trilogy::Error is the base error type. All errors raised by Trilogy
+  # should be descendants of Trilogy::Error
+  module Error
+    attr_reader :error_code
+  end
+
+  # Trilogy::ConnectionError is the base error type for all potentially transient
+  # network errors.
+  module ConnectionError
+    include Error
+  end
+
+  # Trilogy may raise various syscall errors, which we treat as Trilogy::Errors.
+  class SyscallError
+    ERRORS = {}
+
+    Errno.constants
+      .map { |c| Errno.const_get(c) }.uniq
+      .select { |c| c.is_a?(Class) && c < SystemCallError }
+      .each do |c|
+        errno_name = c.to_s.split('::').last
+        ERRORS[c::Errno] = const_set(errno_name, Class.new(c) { include Trilogy::Error })
+      end
+
+    ERRORS.freeze
+
+    class << self
+      def from_errno(errno, message)
+        ERRORS[errno].new(message)
+      end
+    end
+  end
+
+  class BaseError < StandardError
+    include Error
+
+    def initialize(error_message = nil, error_code = nil)
+      message = error_code ? "#{error_code}: #{error_message}" : error_message
+      super(message)
+      @error_code = error_code
+    end
+  end
+
+  class BaseConnectionError < BaseError
+    include ConnectionError
+  end
+
+  # Trilogy::ClientError is the base error type for invalid queries or parameters
+  # that shouldn't be retried.
+  class ClientError < BaseError
+    include Error
+  end
+
+  class QueryError < ClientError
+  end
+
+  class CastError < ClientError
+  end
+
+  class TimeoutError < Errno::ETIMEDOUT
+    include ConnectionError
+
+    def initialize(error_message = nil, error_code = nil)
+      super
+      @error_code = error_code
+    end
+  end
+
+  class ConnectionRefusedError < Errno::ECONNREFUSED
+    include ConnectionError
+  end
+
+  class ConnectionResetError < Errno::ECONNRESET
+    include ConnectionError
+  end
+
+  # DatabaseError was replaced by ProtocolError, but we'll keep it around as an
+  # ancestor of ProtocolError for compatibility reasons (e.g. so `rescue DatabaseError`
+  # still works. We can remove this class in the next major release.
+  module DatabaseError
+  end
+
+  class ProtocolError < BaseError
+    include DatabaseError
+
+    ERROR_CODES = {
+      1205 => TimeoutError, # ER_LOCK_WAIT_TIMEOUT
+      1044 => BaseConnectionError, # ER_DBACCESS_DENIED_ERROR
+      1045 => BaseConnectionError, # ER_ACCESS_DENIED_ERROR
+      1064 => QueryError, # ER_PARSE_ERROR
+      1152 => BaseConnectionError, # ER_ABORTING_CONNECTION
+      1153 => BaseConnectionError, # ER_NET_PACKET_TOO_LARGE
+      1154 => BaseConnectionError, # ER_NET_READ_ERROR_FROM_PIPE
+      1155 => BaseConnectionError, # ER_NET_FCNTL_ERROR
+      1156 => BaseConnectionError, # ER_NET_PACKETS_OUT_OF_ORDER
+      1157 => BaseConnectionError, # ER_NET_UNCOMPRESS_ERROR
+      1158 => BaseConnectionError, # ER_NET_READ_ERROR
+      1159 => BaseConnectionError, # ER_NET_READ_INTERRUPTED
+      1160 => BaseConnectionError, # ER_NET_ERROR_ON_WRITE
+      1161 => BaseConnectionError, # ER_NET_WRITE_INTERRUPTED
+      1927 => BaseConnectionError, # ER_CONNECTION_KILLED
+    }
+    class << self
+      def from_code(message, code)
+        ERROR_CODES.fetch(code, self).new(message, code)
+      end
+    end
+  end
+
+  class SSLError < BaseError
+    include ConnectionError
+  end
+
+  class ConnectionClosed < IOError
+    include ConnectionError
+  end
+end

data/lib/trilogy/result.rb

@@ -0,0 +1,33 @@
+class Trilogy
+  class Result
+    attr_reader :fields, :rows, :query_time, :affected_rows, :last_insert_id
+
+    def count
+      rows.count
+    end
+
+    def each_hash
+      return enum_for(:each_hash) unless block_given?
+
+      rows.each do |row|
+        this_row = {}
+
+        idx = 0
+        row.each do |col|
+          this_row[fields[idx]] = col
+          idx += 1
+        end
+
+        yield this_row
+      end
+
+      self
+    end
+
+    def each(&bk)
+      rows.each(&bk)
+    end
+
+    include Enumerable
+  end
+end

data/lib/trilogy/version.rb

@@ -1,3 +1,3 @@
 class Trilogy
-  VERSION = "2.4.0"
+  VERSION = "2.5.0"
 end