trilogy 2.6.1 → 2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d015527cefe1e66b73b4db1d31b98e3db6ab616edb1fb2da947054a55818f338
-  data.tar.gz: 315bdd0e7dabf0f37ed69f5cd0884a702a7502443b1e26e5b01bec90b122e11d
+  metadata.gz: 998b06e77dcb78b2f30307834490a7c9c7d61422dea586f646cead7b74467058
+  data.tar.gz: e5bf1ecf9e8b2b675db0d3c3ee7531db4ab022aa725c4ed0c16db088884c6075
 SHA512:
-  metadata.gz: b6e50321b8493b6ea8137d534e0fa8eedc5b7388093fee5e910dbe8c6bd81c0e0dc9c8d9c448895096fb8bd0244a0ee65b19b5f580c3b9137c76c9af221f0ab2
-  data.tar.gz: 7d8b81caf8faaadc4ef548ffddab7a73f9b8d4d6ede5a0f9078c6ea65cd195f83bdcacdf5a3d7b71d76503161a689d8ac66b058a4c605a915f9a9dcf4aa56cdd
+  metadata.gz: bd2acff1c38bbed9bea64f3fbb9ad474e4d42198dccbcdca0aa1b8ba3b52e35711f1c9e2e1a6859c15a71c38ed08ba06b5adcb5fbb5054b1b4264fd51ae0933f
+  data.tar.gz: e032a04cfb901d48a4e1e711cd576c380562f2b7f871724d06568dff8bd3b599fd3ea86360b3bcbe2f8f9471f986d6b1cc8f8d8e69309877778d1ce442dd65f3

data/ext/trilogy-ruby/cext.c

@@ -17,13 +17,13 @@
 
 VALUE Trilogy_CastError;
 static VALUE Trilogy_BaseConnectionError, Trilogy_ProtocolError, Trilogy_SSLError, Trilogy_QueryError,
-    Trilogy_ConnectionClosedError, Trilogy_ConnectionRefusedError, Trilogy_ConnectionResetError,
-    Trilogy_TimeoutError, Trilogy_SyscallError, Trilogy_Result, Trilogy_EOFError;
+    Trilogy_ConnectionClosedError,
+    Trilogy_TimeoutError, Trilogy_SyscallError, Trilogy_Result, Trilogy_EOFError, Trilogy_AuthPluginError;
 
 static ID id_socket, id_host, id_port, id_username, id_password, id_found_rows, id_connect_timeout, id_read_timeout,
     id_write_timeout, id_keepalive_enabled, id_keepalive_idle, id_keepalive_interval, id_keepalive_count,
     id_ivar_affected_rows, id_ivar_fields, id_ivar_last_insert_id, id_ivar_rows, id_ivar_query_time, id_password,
-    id_database, id_ssl_ca, id_ssl_capath, id_ssl_cert, id_ssl_cipher, id_ssl_crl, id_ssl_crlpath, id_ssl_key,
+    id_database, id_enable_cleartext_plugin, id_ssl_ca, id_ssl_capath, id_ssl_cert, id_ssl_cipher, id_ssl_crl, id_ssl_crlpath, id_ssl_key,
     id_ssl_mode, id_tls_ciphersuites, id_tls_min_version, id_tls_max_version, id_multi_statement, id_multi_result,
     id_from_code, id_from_errno, id_connection_options, id_max_allowed_packet;
 
@@ -88,12 +88,8 @@ static struct trilogy_ctx *get_open_ctx(VALUE obj)
 NORETURN(static void trilogy_syserr_fail_str(int, VALUE));
 static void trilogy_syserr_fail_str(int e, VALUE msg)
 {
-    if (e == ECONNREFUSED) {
-        rb_raise(Trilogy_ConnectionRefusedError, "%" PRIsVALUE, msg);
-    } else if (e == ECONNRESET) {
-        rb_raise(Trilogy_ConnectionResetError, "%" PRIsVALUE, msg);
-    } else if (e == EPIPE) {
-        // Backwards compatibility: This error class makes no sense, but matches legacy behavior
+    if (e == EPIPE) {
+        // Backwards compatibility: This error message is a bit odd, but includes "TRILOGY_CLOSED_CONNECTION" to match legacy string matching
         rb_raise(Trilogy_EOFError, "%" PRIsVALUE ": TRILOGY_CLOSED_CONNECTION: EPIPE", msg);
     } else {
         VALUE exc = rb_funcall(Trilogy_SyscallError, id_from_errno, 2, INT2NUM(e), msg);
@@ -137,7 +133,8 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
         rb_raise(Trilogy_TimeoutError, "%" PRIsVALUE, rbmsg);
 
     case TRILOGY_ERR: {
-        VALUE message = rb_str_new(ctx->conn.error_message, ctx->conn.error_message_len);
+        VALUE conn_message = rb_str_new(ctx->conn.error_message, ctx->conn.error_message_len);
+        VALUE message = rb_sprintf("%" PRIsVALUE " (%" PRIsVALUE ")", conn_message, rbmsg);
         VALUE exc = rb_funcall(Trilogy_ProtocolError, id_from_code, 2, message, INT2NUM(ctx->conn.error_code));
         rb_exc_raise(exc);
     }
@@ -160,6 +157,14 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
         rb_raise(Trilogy_EOFError, "%" PRIsVALUE ": TRILOGY_CLOSED_CONNECTION", rbmsg);
     }
 
+    case TRILOGY_AUTH_PLUGIN_ERROR: {
+        rb_raise(Trilogy_AuthPluginError, "%" PRIsVALUE ": TRILOGY_AUTH_PLUGIN_ERROR", rbmsg);
+    }
+
+    case TRILOGY_UNSUPPORTED: {
+        rb_raise(Trilogy_BaseConnectionError, "%" PRIsVALUE ": TRILOGY_UNSUPPORTED", rbmsg);
+    }
+
     default:
         rb_raise(Trilogy_QueryError, "%" PRIsVALUE ": %s", rbmsg, trilogy_error(rc));
     }
@@ -243,7 +248,18 @@ static int _cb_ruby_wait(trilogy_sock_t *sock, trilogy_wait_t wait)
         wait_flag = RB_WAITFD_OUT;
         break;
 
+    case TRILOGY_WAIT_CONNECT:
+        // wait for connection to be writable
+        timeout = &sock->opts.connect_timeout;
+        if (timeout->tv_sec == 0 && timeout->tv_usec == 0) {
+            // We used to use the write timeout for this, so if a connect timeout isn't configured, default to that.
+            timeout = &sock->opts.write_timeout;
+        }
+        wait_flag = RB_WAITFD_OUT;
+        break;
+
     case TRILOGY_WAIT_HANDSHAKE:
+        // wait for handshake packet on initial connection
         timeout = &sock->opts.connect_timeout;
         wait_flag = RB_WAITFD_IN;
         break;
@@ -412,7 +428,12 @@ static void authenticate(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake
         }
 
         if (rc != TRILOGY_AGAIN) {
-            handle_trilogy_error(ctx, rc, "trilogy_auth_recv");
+            if (rc == TRILOGY_UNSUPPORTED) {
+                handle_trilogy_error(ctx, rc, "trilogy_auth_recv: caching_sha2_password requires either TCP with TLS or a unix socket");
+            }
+            else {
+                handle_trilogy_error(ctx, rc, "trilogy_auth_recv");
+            }
         }
 
         rc = trilogy_sock_wait_read(ctx->conn.socket);
@@ -515,6 +536,10 @@ static VALUE rb_trilogy_connect(VALUE self, VALUE encoding, VALUE charset, VALUE
         connopt.flags |= TRILOGY_CAPABILITIES_CONNECT_WITH_DB;
     }
 
+    if (RTEST(rb_hash_aref(opts, ID2SYM(id_enable_cleartext_plugin)))) {
+        connopt.enable_cleartext_plugin = true;
+    }
+
     if (RTEST(rb_hash_aref(opts, ID2SYM(id_found_rows)))) {
         connopt.flags |= TRILOGY_CAPABILITIES_FOUND_ROWS;
     }
@@ -1018,6 +1043,17 @@ static VALUE rb_trilogy_closed(VALUE self)
     }
 }
 
+static VALUE rb_trilogy_check(VALUE self)
+{
+    struct trilogy_ctx *ctx = get_open_ctx(self);
+
+    int rc = trilogy_sock_check(ctx->conn.socket);
+    if (rc != TRILOGY_OK && rc != TRILOGY_AGAIN) {
+        handle_trilogy_error(ctx, rc, "trilogy_sock_check");
+    }
+    return Qtrue;
+}
+
 static VALUE rb_trilogy_discard(VALUE self)
 {
     struct trilogy_ctx *ctx = get_ctx(self);
@@ -1096,8 +1132,12 @@ static VALUE rb_trilogy_server_status(VALUE self) { return LONG2FIX(get_open_ctx
 
 static VALUE rb_trilogy_server_version(VALUE self) { return rb_str_new_cstr(get_open_ctx(self)->server_version); }
 
-RUBY_FUNC_EXPORTED void Init_cext()
+RUBY_FUNC_EXPORTED void Init_cext(void)
 {
+    #ifdef HAVE_RB_EXT_RACTOR_SAFE
+        rb_ext_ractor_safe(true);
+    #endif
+
     VALUE Trilogy = rb_const_get(rb_cObject, rb_intern("Trilogy"));
     rb_define_alloc_func(Trilogy, allocate_trilogy);
 
@@ -1109,6 +1149,7 @@ RUBY_FUNC_EXPORTED void Init_cext()
     rb_define_method(Trilogy, "escape", rb_trilogy_escape, 1);
     rb_define_method(Trilogy, "close", rb_trilogy_close, 0);
     rb_define_method(Trilogy, "closed?", rb_trilogy_closed, 0);
+    rb_define_method(Trilogy, "check", rb_trilogy_check, 0);
     rb_define_method(Trilogy, "discard!", rb_trilogy_discard, 0);
     rb_define_method(Trilogy, "last_insert_id", rb_trilogy_last_insert_id, 0);
     rb_define_method(Trilogy, "affected_rows", rb_trilogy_affected_rows, 0);
@@ -1156,12 +1197,6 @@ RUBY_FUNC_EXPORTED void Init_cext()
     Trilogy_TimeoutError = rb_const_get(Trilogy, rb_intern("TimeoutError"));
     rb_global_variable(&Trilogy_TimeoutError);
 
-    Trilogy_ConnectionRefusedError = rb_const_get(Trilogy, rb_intern("ConnectionRefusedError"));
-    rb_global_variable(&Trilogy_ConnectionRefusedError);
-
-    Trilogy_ConnectionResetError = rb_const_get(Trilogy, rb_intern("ConnectionResetError"));
-    rb_global_variable(&Trilogy_ConnectionResetError);
-
     Trilogy_BaseConnectionError = rb_const_get(Trilogy, rb_intern("BaseConnectionError"));
     rb_global_variable(&Trilogy_BaseConnectionError);
 
@@ -1180,6 +1215,9 @@ RUBY_FUNC_EXPORTED void Init_cext()
     Trilogy_EOFError = rb_const_get(Trilogy, rb_intern("EOFError"));
     rb_global_variable(&Trilogy_EOFError);
 
+    rb_global_variable(&Trilogy_AuthPluginError);
+    Trilogy_AuthPluginError = rb_const_get(Trilogy, rb_intern("AuthPluginError"));
+
     id_socket = rb_intern("socket");
     id_host = rb_intern("host");
     id_port = rb_intern("port");
@@ -1195,6 +1233,7 @@ RUBY_FUNC_EXPORTED void Init_cext()
     id_keepalive_count = rb_intern("keepalive_count");
     id_keepalive_interval = rb_intern("keepalive_interval");
     id_database = rb_intern("database");
+    id_enable_cleartext_plugin = rb_intern("enable_cleartext_plugin");
     id_ssl_ca = rb_intern("ssl_ca");
     id_ssl_capath = rb_intern("ssl_capath");
     id_ssl_cert = rb_intern("ssl_cert");

data/ext/trilogy-ruby/inc/trilogy/error.h

@@ -24,7 +24,8 @@
     XX(TRILOGY_AUTH_SWITCH, -19)                                                                                       \
     XX(TRILOGY_MAX_PACKET_EXCEEDED, -20)                                                                               \
     XX(TRILOGY_UNKNOWN_TYPE, -21)                                                                                      \
-    XX(TRILOGY_TIMEOUT, -22)
+    XX(TRILOGY_TIMEOUT, -22)                                                                                           \
+    XX(TRILOGY_AUTH_PLUGIN_ERROR, -23)
 
 enum {
 #define XX(name, code) name = code,

data/ext/trilogy-ruby/inc/trilogy/protocol.h

@@ -289,6 +289,7 @@ typedef enum {
     XX(TRILOGY_TYPE_YEAR, 0x0d)                                                                                        \
     XX(TRILOGY_TYPE_VARCHAR, 0x0f)                                                                                     \
     XX(TRILOGY_TYPE_BIT, 0x10)                                                                                         \
+    XX(TRILOGY_TYPE_VECTOR, 0xf2)                                                                                      \
     XX(TRILOGY_TYPE_JSON, 0xf5)                                                                                        \
     XX(TRILOGY_TYPE_NEWDECIMAL, 0xf6)                                                                                  \
     XX(TRILOGY_TYPE_ENUM, 0xf7)                                                                                        \
@@ -367,6 +368,7 @@ typedef enum {
 // Typical response packet types
 typedef enum {
     TRILOGY_PACKET_OK = 0x0,
+    TRILOGY_PACKET_AUTH_MORE_DATA = 0x01,
     TRILOGY_PACKET_EOF = 0xfe,
     TRILOGY_PACKET_ERR = 0xff,
     TRILOGY_PACKET_UNKNOWN
@@ -442,14 +444,16 @@ int trilogy_build_auth_packet(trilogy_builder_t *builder, const char *user, cons
  * pass_len    - The length of password in bytes.
  * auth_plugin - Plugin authentication mechanism that the server requested.
  * scramble    - The scramble value received from the server.
+ * enable_cleartext_plugin - Send cleartext password if requested by server.
  *
  * Return values:
  *   TRILOGY_OK     - The packet was successfully built and written to the
  *                    builder's internal buffer.
  *   TRILOGY_SYSERR - A system error occurred, check errno.
+ *   TRILOGY_AUTH_PLUGIN_ERROR - The server requested auth plugin is not supported.
  */
 int trilogy_build_auth_switch_response_packet(trilogy_builder_t *builder, const char *pass, size_t pass_len,
-                                              const char *auth_plugin, const char *scramble);
+                                              const char *auth_plugin, const char *scramble, const bool enable_cleartext_plugin);
 
 /* trilogy_build_change_db_packet - Build a change database command packet. This
  * command will change the default database for the connection.
@@ -1035,4 +1039,6 @@ int trilogy_parse_stmt_ok_packet(const uint8_t *buff, size_t len, trilogy_stmt_o
 int trilogy_parse_stmt_row_packet(const uint8_t *buff, size_t len, trilogy_column_packet_t *columns,
                                   uint64_t column_count, trilogy_binary_value_t *out_values);
 
+int trilogy_build_auth_clear_password(trilogy_builder_t *builder, const char *pass, size_t pass_len);
+
 #endif

data/ext/trilogy-ruby/inc/trilogy/socket.h

@@ -13,6 +13,7 @@ typedef enum {
     TRILOGY_WAIT_READ = 0,
     TRILOGY_WAIT_WRITE = 1,
     TRILOGY_WAIT_HANDSHAKE = 2,
+    TRILOGY_WAIT_CONNECT = 3,
 } trilogy_wait_t;
 
 // We use the most strict mode as value 1 so if anyone ever
@@ -66,6 +67,8 @@ typedef struct {
     uint16_t keepalive_count;
     uint16_t keepalive_interval;
 
+    bool enable_cleartext_plugin;
+
     TRILOGY_CAPABILITIES_t flags;
 
     size_t max_allowed_packet;
@@ -111,4 +114,20 @@ trilogy_sock_t *trilogy_sock_new(const trilogy_sockopt_t *opts);
 int trilogy_sock_resolve(trilogy_sock_t *raw);
 int trilogy_sock_upgrade_ssl(trilogy_sock_t *raw);
 
+/* trilogy_sock_check - Verify if the socket is still alive and not disconnected.
+ *
+ * This check is very cheap to do and reduces the number of errors when for
+ * example the server has restarted since the connection was opened. In connection
+ * pooling implementations, this check can be done before the connection is
+ * returned.
+ *
+ * raw - A connected trilogy_sock_t pointer. Using a disconnected trilogy_sock_t is undefined.
+ *
+ * Return values:
+ *   TRILOGY_OK                - The connection is alive on the client side and can be.
+ *   TRILOGY_CLOSED_CONNECTION - The connection is closed.
+ *   TRILOGY_SYSERR            - A system error occurred, check errno.
+ */
+int trilogy_sock_check(trilogy_sock_t *raw);
+
 #endif

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

@@ -182,7 +182,7 @@ int trilogy_builder_write_buffer(trilogy_builder_t *builder, const void *data, s
 
     size_t fragment_remaining = TRILOGY_MAX_PACKET_LEN - builder->fragment_length;
 
-    if (builder->packet_length >= builder->packet_max_length - len) {
+    if (builder->packet_length + len >= builder->packet_max_length) {
         return TRILOGY_MAX_PACKET_EXCEEDED;
     }
 

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

@@ -248,8 +248,9 @@ static int read_auth_switch_packet(trilogy_conn_t *conn, trilogy_handshake_t *ha
     }
 
     if (strcmp("mysql_native_password", auth_switch_packet.auth_plugin) &&
-        strcmp("caching_sha2_password", auth_switch_packet.auth_plugin)) {
-        // Only support native password & caching sha2 password here.
+        strcmp("caching_sha2_password", auth_switch_packet.auth_plugin) &&
+        strcmp("mysql_clear_password", auth_switch_packet.auth_plugin)) {
+        // Only support native password, caching sha2 and cleartext password here.
         return TRILOGY_PROTOCOL_VIOLATION;
     }
 
@@ -258,14 +259,7 @@ static int read_auth_switch_packet(trilogy_conn_t *conn, trilogy_handshake_t *ha
     return TRILOGY_AUTH_SWITCH;
 }
 
-static int read_generic_response(trilogy_conn_t *conn)
-{
-    int rc = read_packet(conn);
-
-    if (rc < 0) {
-        return rc;
-    }
-
+static int handle_generic_response(trilogy_conn_t *conn) {
     switch (current_packet_type(conn)) {
     case TRILOGY_PACKET_OK:
         return read_ok_packet(conn);
@@ -278,6 +272,17 @@ static int read_generic_response(trilogy_conn_t *conn)
     }
 }
 
+static int read_generic_response(trilogy_conn_t *conn)
+{
+    int rc = read_packet(conn);
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    return handle_generic_response(conn);
+}
+
 int trilogy_connect_send(trilogy_conn_t *conn, const trilogy_sockopt_t *opts)
 {
     trilogy_sock_t *sock = trilogy_sock_new(opts);
@@ -300,14 +305,13 @@ int trilogy_connect_send_socket(trilogy_conn_t *conn, trilogy_sock_t *sock)
         return rc;
 
     conn->socket = sock;
+    conn->packet_parser.sequence_number = 0;
+
     return TRILOGY_OK;
 }
 
 int trilogy_connect_recv(trilogy_conn_t *conn, trilogy_handshake_t *handshake_out)
 {
-    // reset the sequence number with each connect recv attempt
-    conn->packet_parser.sequence_number = 0;
-
     int rc = read_packet(conn);
 
     if (rc < 0) {
@@ -336,9 +340,8 @@ int trilogy_connect_recv(trilogy_conn_t *conn, trilogy_handshake_t *handshake_ou
 int trilogy_auth_send(trilogy_conn_t *conn, const trilogy_handshake_t *handshake)
 {
     trilogy_builder_t builder;
-    bool use_ssl = (conn->socket->opts.flags & TRILOGY_CAPABILITIES_SSL) != 0;
 
-    int rc = begin_command_phase(&builder, conn, use_ssl ? 2 : 1);
+    int rc = begin_command_phase(&builder, conn, conn->packet_parser.sequence_number);
 
     if (rc < 0) {
         return rc;
@@ -360,7 +363,7 @@ int trilogy_ssl_request_send(trilogy_conn_t *conn)
 {
     trilogy_builder_t builder;
 
-    int rc = begin_command_phase(&builder, conn, 1);
+    int rc = begin_command_phase(&builder, conn, conn->packet_parser.sequence_number);
 
     if (rc < 0) {
         return rc;
@@ -380,8 +383,7 @@ int trilogy_auth_switch_send(trilogy_conn_t *conn, const trilogy_handshake_t *ha
 {
     trilogy_builder_t builder;
 
-    bool use_ssl = (conn->socket->opts.flags & TRILOGY_CAPABILITIES_SSL) != 0;
-    int rc = begin_command_phase(&builder, conn, use_ssl ? 4 : 3);
+    int rc = begin_command_phase(&builder, conn, conn->packet_parser.sequence_number);
 
     if (rc < 0) {
         return rc;
@@ -389,7 +391,7 @@ int trilogy_auth_switch_send(trilogy_conn_t *conn, const trilogy_handshake_t *ha
 
     rc = trilogy_build_auth_switch_response_packet(&builder, conn->socket->opts.password,
                                                    conn->socket->opts.password_len, handshake->auth_plugin,
-                                                   handshake->scramble);
+                                                   handshake->scramble, conn->socket->opts.enable_cleartext_plugin);
 
     if (rc < 0) {
         return rc;
@@ -405,6 +407,9 @@ void trilogy_auth_clear_password(trilogy_conn_t *conn)
     }
 }
 
+#define FAST_AUTH_OK 3
+#define FAST_AUTH_FAIL 4
+
 int trilogy_auth_recv(trilogy_conn_t *conn, trilogy_handshake_t *handshake)
 {
     int rc = read_packet(conn);
@@ -414,13 +419,69 @@ int trilogy_auth_recv(trilogy_conn_t *conn, trilogy_handshake_t *handshake)
     }
 
     switch (current_packet_type(conn)) {
-    case TRILOGY_PACKET_OK:
-        trilogy_auth_clear_password(conn);
-        return read_ok_packet(conn);
+    case TRILOGY_PACKET_AUTH_MORE_DATA: {
+        bool use_ssl = (conn->socket->opts.flags & TRILOGY_CAPABILITIES_SSL) != 0;
+        bool has_unix_socket = (conn->socket->opts.path != NULL);
 
-    case TRILOGY_PACKET_ERR:
+        if (!use_ssl && !has_unix_socket) {
+            return TRILOGY_UNSUPPORTED;
+        }
+
+        uint8_t byte = conn->packet_buffer.buff[1];
+        switch (byte) {
+            case FAST_AUTH_OK:
+                break;
+            case FAST_AUTH_FAIL:
+                {
+                    trilogy_builder_t builder;
+                    int err = begin_command_phase(&builder, conn, conn->packet_parser.sequence_number);
+
+                    if (err < 0) {
+                        return err;
+                    }
+
+                    err = trilogy_build_auth_clear_password(&builder, conn->socket->opts.password, conn->socket->opts.password_len);
+
+                    if (err < 0) {
+                        return err;
+                    }
+
+                    int rc = begin_write(conn);
+
+                    while (rc == TRILOGY_AGAIN) {
+                        rc = trilogy_sock_wait_write(conn->socket);
+                        if (rc != TRILOGY_OK) {
+                            return rc;
+                        }
+
+                        rc = trilogy_flush_writes(conn);
+                    }
+                    if (rc != TRILOGY_OK) {
+                        return rc;
+                    }
+
+                    break;
+                }
+            default:
+                return TRILOGY_UNEXPECTED_PACKET;
+        }
+        while (1) {
+            rc = read_packet(conn);
+
+            if (rc == TRILOGY_OK) {
+                break;
+            }
+            else if (rc == TRILOGY_AGAIN) {
+                rc = trilogy_sock_wait_read(conn->socket);
+            }
+
+            if (rc != TRILOGY_OK) {
+                return rc;
+            }
+        }
         trilogy_auth_clear_password(conn);
-        return read_err_packet(conn);
+        return handle_generic_response(conn);
+    }
 
     case TRILOGY_PACKET_EOF:
         // EOF is returned here if an auth switch is requested.
@@ -428,9 +489,11 @@ int trilogy_auth_recv(trilogy_conn_t *conn, trilogy_handshake_t *handshake)
         // in a follow up call to this function after the switch.
         return read_auth_switch_packet(conn, handshake);
 
+    case TRILOGY_PACKET_OK:
+    case TRILOGY_PACKET_ERR:
     default:
         trilogy_auth_clear_password(conn);
-        return TRILOGY_UNEXPECTED_PACKET;
+        return handle_generic_response(conn);
     }
 
     return read_generic_response(conn);

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

@@ -593,28 +593,48 @@ int trilogy_build_auth_packet(trilogy_builder_t *builder, const char *user, cons
 
     trilogy_builder_finalize(builder);
 
-    return TRILOGY_OK;
+fail:
+    return rc;
+}
+
+int trilogy_build_auth_clear_password(trilogy_builder_t *builder, const char *pass, size_t pass_len) {
+    int rc = TRILOGY_OK;
+
+    CHECKED(trilogy_builder_write_buffer(builder, pass, pass_len));
+    CHECKED(trilogy_builder_write_uint8(builder, 0));
+    trilogy_builder_finalize(builder);
 
 fail:
     return rc;
 }
 
 int trilogy_build_auth_switch_response_packet(trilogy_builder_t *builder, const char *pass, size_t pass_len,
-                                              const char *auth_plugin, const char *scramble)
+                                              const char *auth_plugin, const char *scramble, const bool enable_cleartext_plugin)
 {
     int rc = TRILOGY_OK;
     unsigned int auth_response_len = 0;
     uint8_t auth_response[EVP_MAX_MD_SIZE];
 
     if (pass_len > 0) {
-        if (!strcmp("caching_sha2_password", auth_plugin)) {
-            trilogy_pack_scramble_sha2_hash(scramble, pass, pass_len, auth_response, &auth_response_len);
+        if (!strcmp("mysql_clear_password", auth_plugin)) {
+            if (enable_cleartext_plugin) {
+                CHECKED(trilogy_builder_write_buffer(builder, pass, pass_len));
+            } else {
+                return TRILOGY_AUTH_PLUGIN_ERROR;
+            }
         } else {
-            trilogy_pack_scramble_native_hash(scramble, pass, pass_len, auth_response, &auth_response_len);
+            if (!strcmp("caching_sha2_password", auth_plugin)) {
+                trilogy_pack_scramble_sha2_hash(scramble, pass, pass_len, auth_response, &auth_response_len);
+            } else if (!strcmp("mysql_native_password", auth_plugin)) {
+                trilogy_pack_scramble_native_hash(scramble, pass, pass_len, auth_response, &auth_response_len);
+            } else {
+                return TRILOGY_AUTH_PLUGIN_ERROR;
+            }
+
+            CHECKED(trilogy_builder_write_buffer(builder, auth_response, auth_response_len));
         }
     }
 
-    CHECKED(trilogy_builder_write_buffer(builder, auth_response, auth_response_len));
     trilogy_builder_finalize(builder);
 
     return TRILOGY_OK;
@@ -906,6 +926,8 @@ int trilogy_build_stmt_execute_packet(trilogy_builder_t *builder, uint32_t stmt_
             case TRILOGY_TYPE_VAR_STRING:
             case TRILOGY_TYPE_STRING:
             case TRILOGY_TYPE_GEOMETRY:
+            case TRILOGY_TYPE_JSON:
+            case TRILOGY_TYPE_VECTOR:
                 CHECKED(trilogy_builder_write_lenenc_buffer(builder, val.as.str.data, val.as.str.len));
 
                 break;
@@ -1039,6 +1061,7 @@ int trilogy_parse_stmt_row_packet(const uint8_t *buff, size_t len, trilogy_colum
             case TRILOGY_TYPE_DECIMAL:
             case TRILOGY_TYPE_NEWDECIMAL:
             case TRILOGY_TYPE_JSON:
+            case TRILOGY_TYPE_VECTOR:
                 CHECKED(trilogy_reader_get_lenenc_buffer(&reader, &out_values[i].as.str.len,
                                                       (const void **)&out_values[i].as.str.data));
 

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

@@ -40,6 +40,7 @@ static int _cb_wait(trilogy_sock_t *_sock, trilogy_wait_t wait)
     case TRILOGY_WAIT_READ:
         pfd.events = POLLIN;
         break;
+    case TRILOGY_WAIT_CONNECT:
     case TRILOGY_WAIT_WRITE:
         pfd.events = POLLOUT;
         break;
@@ -252,7 +253,7 @@ static int raw_connect_internal(struct trilogy_sock *sock, const struct addrinfo
         }
     }
 
-    if ((rc = trilogy_sock_wait_write((trilogy_sock_t *)sock)) < 0) {
+    if ((rc = trilogy_sock_wait((trilogy_sock_t *)sock, TRILOGY_WAIT_CONNECT)) < 0) {
         goto failrc;
     }
 
@@ -724,3 +725,25 @@ fail:
     sock->ssl = NULL;
     return TRILOGY_OPENSSL_ERR;
 }
+
+int trilogy_sock_check(trilogy_sock_t *_sock)
+{
+    struct trilogy_sock *sock = (struct trilogy_sock *)_sock;
+    char buf[1];
+    while (1) {
+        ssize_t data_read = recv(sock->fd, buf, 1, MSG_PEEK);
+        if (data_read > 0) {
+            return TRILOGY_OK;
+        }
+        if (data_read == 0) {
+            return TRILOGY_CLOSED_CONNECTION;
+        }
+        if (errno == EINTR) {
+            continue;
+        }
+        if (errno == EAGAIN || errno == EWOULDBLOCK) {
+            return TRILOGY_OK;
+        }
+        return TRILOGY_SYSERR;
+    }
+}

data/lib/trilogy/error.rb

@@ -12,7 +12,7 @@ class Trilogy
   end
 
   # Trilogy may raise various syscall errors, which we treat as Trilogy::Errors.
-  class SyscallError
+  module SyscallError
     ERRORS = {}
 
     Errno.constants
@@ -20,7 +20,10 @@ class Trilogy
       .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::ConnectionError })
+        ERRORS[c::Errno] = const_set(errno_name, Class.new(c) {
+          include Trilogy::ConnectionError
+          singleton_class.define_method(:===, Module.instance_method(:===))
+        })
       end
 
     ERRORS.freeze
@@ -32,6 +35,11 @@ class Trilogy
     end
   end
 
+  ConnectionRefusedError = SyscallError::ECONNREFUSED
+  deprecate_constant :ConnectionRefusedError
+  ConnectionResetError = SyscallError::ECONNRESET
+  deprecate_constant :ConnectionResetError
+
   class BaseError < StandardError
     include Error
 
@@ -58,21 +66,7 @@ class Trilogy
   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
+  class TimeoutError < BaseConnectionError
   end
 
   # DatabaseError was replaced by ProtocolError, but we'll keep it around as an
@@ -121,4 +115,9 @@ class Trilogy
   # attempted on a socket which previously encountered an error.
   class EOFError < BaseConnectionError
   end
+
+  # Occurs when the server request an auth switch to an incompatible
+  # authentication plugin
+  class AuthPluginError < Trilogy::BaseConnectionError
+  end
 end

data/lib/trilogy/version.rb

@@ -1,3 +1,3 @@
 class Trilogy
-  VERSION = "2.6.1"
+  VERSION = "2.9.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trilogy
 version: !ruby/object:Gem::Version
-  version: 2.6.1
+  version: 2.9.0
 platform: ruby
 authors:
 - GitHub Engineering
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-04 00:00:00.000000000 Z
+date: 2024-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -102,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A friendly MySQL-compatible library for Ruby, binding to libtrilogy