trilogy 2.0.0

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

@@ -0,0 +1,212 @@
+#ifndef TRILOGY_READER_H
+#define TRILOGY_READER_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/* Trilogy Packet Reader API
+ *
+ * The packet reader API is used to parse MySQL-compatible protocol packets.
+ */
+
+/* trilogy_reader_t - The reader API's instance type.
+ */
+typedef struct {
+    const uint8_t *buff;
+    size_t len;
+    size_t pos;
+} trilogy_reader_t;
+
+/* trilogy_reader_init - Initialize a pre-allocated trilogy_reader_t.
+ *
+ * reader - A pointer to a pre-allocated trilogy_reader_t.
+ * buff   - A pointer to a buffer containing MySQL-compatible protocol packet data.
+ * len    - The length of `buff` in bytes.
+ *
+ * Returns nothing.
+ */
+void trilogy_reader_init(trilogy_reader_t *reader, const uint8_t *buff, size_t len);
+
+#define TRILOGY_READER(buffer, length) ((trilogy_reader_t){.buff = (buffer), .len = (length), .pos = 0});
+
+/* trilogy_reader_get_uint8 - Parse an unsigned 8-bit integer.
+ *
+ * reader - A pointer to a pre-initialized trilogy_reader_t.
+ * out    - Out parameter; A pointer to a uint8_t which will be set to the
+ *          value read from the buffer.
+ *
+ * Return values:
+ *   TRILOGY_OK               - The value was parsed.
+ *   TRILOGY_TRUNCATED_PACKET - There isn't enough data left in the buffer.
+ */
+int trilogy_reader_get_uint8(trilogy_reader_t *reader, uint8_t *out);
+
+/* trilogy_reader_get_uint16 - Parse an unsigned 16-bit integer.
+ *
+ * reader - A pointer to a pre-initialized trilogy_reader_t.
+ * out    - Out parameter; A pointer to a uint16_t which will be set to the
+ *          value read from the buffer.
+ *
+ * Return values:
+ *   TRILOGY_OK               - The value was parsed.
+ *   TRILOGY_TRUNCATED_PACKET - There isn't enough data left in the buffer.
+ */
+int trilogy_reader_get_uint16(trilogy_reader_t *reader, uint16_t *out);
+
+/* trilogy_reader_get_uint24 - Parse an unsigned 24-bit integer.
+ *
+ * reader - A pointer to a pre-initialized trilogy_reader_t.
+ * out    - Out parameter; A pointer to a uint32_t which will be set to the
+ *          value read from the buffer.
+ *
+ * Return values:
+ *   TRILOGY_OK               - The value was parsed.
+ *   TRILOGY_TRUNCATED_PACKET - There isn't enough data left in the buffer.
+ */
+int trilogy_reader_get_uint24(trilogy_reader_t *reader, uint32_t *out);
+
+/* trilogy_reader_get_uint32 - Parse an unsigned 32-bit integer.
+ *
+ * reader - A pointer to a pre-initialized trilogy_reader_t.
+ * out    - Out parameter; A pointer to a uint32_t which will be set to the
+ *          value read from the buffer.
+ *
+ * Return values:
+ *   TRILOGY_OK               - The value was parsed.
+ *   TRILOGY_TRUNCATED_PACKET - There isn't enough data left in the buffer.
+ */
+int trilogy_reader_get_uint32(trilogy_reader_t *reader, uint32_t *out);
+
+/* trilogy_reader_get_uint64 - Parse an unsigned 64-bit integer.
+ *
+ * reader - A pointer to a pre-initialized trilogy_reader_t.
+ * out    - Out parameter; A pointer to a uint64_t which will be set to the
+ *          value read from the buffer.
+ *
+ * Return values:
+ *   TRILOGY_OK               - The value was parsed.
+ *   TRILOGY_TRUNCATED_PACKET - There isn't enough data left in the buffer.
+ */
+int trilogy_reader_get_uint64(trilogy_reader_t *reader, uint64_t *out);
+
+/* trilogy_reader_get_lenenc - Parse an unsigned, length-encoded integer.
+ *
+ * reader - A pointer to a pre-initialized trilogy_reader_t.
+ * out    - Out parameter; A pointer to a uint64_t which will be set to the
+ *          value read from the buffer.
+ *
+ * Return values:
+ *   TRILOGY_OK               - The value was parsed.
+ *   TRILOGY_TRUNCATED_PACKET - There isn't enough data left in the buffer.
+ */
+int trilogy_reader_get_lenenc(trilogy_reader_t *reader, uint64_t *out);
+
+/* trilogy_reader_get_buffer - Parse an opaque set of bytes from the packet,
+ * pointing the dereferenced value of `out` to the beginning of the set.
+ *
+ * reader - A pointer to a pre-initialized trilogy_reader_t.
+ * len    - The number of bytes to attempt to read from the buffer.
+ * out    - Out parameter; A pointer to a void* which will be set to the
+ *          beginning of the opaque buffer. This will be a pointer into the
+ *          buffer that was originally passed to trilogy_reader_init. No copies
+ * are made internally.
+ *
+ * Return values:
+ *   TRILOGY_OK               - The value was parsed and the dereferenced value of
+ *                           `out` now points to it.
+ *   TRILOGY_TRUNCATED_PACKET - There isn't enough data left in the buffer.
+ */
+int trilogy_reader_get_buffer(trilogy_reader_t *reader, size_t len, const void **out);
+
+/* trilogy_reader_copy_buffer - Parse an opaque set of bytes from the packet and
+ * copy them into `out`. `out` must be allocated with at least `len` bytes.
+ *
+ * reader - A pointer to a pre-initialized trilogy_reader_t.
+ * len    - The number of bytes to attempt to read from the buffer.
+ * out    - A pointer to the address to copy `len` bytes from the packet buffer
+ *          to.
+ *
+ * Return values:
+ *   TRILOGY_OK               - The value was parsed and copied into the location
+ *                           `out` points to.
+ *   TRILOGY_TRUNCATED_PACKET - There isn't enough data left in the buffer.
+ */
+int trilogy_reader_copy_buffer(trilogy_reader_t *reader, size_t len, void *out);
+
+/* trilogy_reader_get_lenenc_buffer - Parse an opaque set of bytes from the
+ * packet, pointing the dereferenced value of `out` to the beginning of the set.
+ * The length of the buffer is defined by a preceding length-encoded integer,
+ * who's value will be copied in to `out_len`.
+ *
+ * reader  - A pointer to a pre-initialized trilogy_reader_t.
+ * out_len - Out parameter; The length of the read buffer in bytes.
+ * out     - Out parameter; A pointer to a void* which will be set to the
+ *           beginning of the opaque buffer.
+ *
+ * Return values:
+ *   TRILOGY_OK               - The value was parsed and the dereferenced value of
+ *                           `out` now points to it.
+ *   TRILOGY_TRUNCATED_PACKET - There isn't enough data left in the buffer.
+ */
+int trilogy_reader_get_lenenc_buffer(trilogy_reader_t *reader, size_t *out_len, const void **out);
+
+/* trilogy_reader_get_string - Parse a C-string from the packet, pointing the
+ * dereferenced value of `out` to the beginning of the set.
+ *
+ * reader  - A pointer to a pre-initialized trilogy_reader_t.
+ * out_len - Out parameter; The length of the C-string read from the buffer in
+ *           bytes.
+ * out     - Out parameter; A pointer to a void* which will be set to the
+ *           beginning of the C-string.
+ *
+ * Return values:
+ *   TRILOGY_OK               - The value was parsed and the dereferenced value of
+ *                           `out` now points to it.
+ *   TRILOGY_TRUNCATED_PACKET - There isn't enough data left in the buffer.
+ */
+int trilogy_reader_get_string(trilogy_reader_t *reader, const char **out, size_t *out_len);
+
+/* trilogy_reader_get_eof_buffer - Parse an opaque set of bytes from the packet,
+ * pointing the dereferenced value of `out` to the beginning of the set. The
+ * buffer pointed to by `out` will contain the remaining un-parsed bytes from
+ * the packet buffer.
+ *
+ * This will just hand the caller back a pointer into the remainder of the
+ * buffer, even if there aren't any more bytes left to read. As a result, this
+ * function will only ever return TRILOGY_OK.
+ *
+ * reader  - A pointer to a pre-initialized trilogy_reader_t.
+ * out_len - Out parameter; The length of the read buffer in bytes.
+ * out     - Out parameter; A pointer to a void* which will be set to the
+ *           beginning of the opaque buffer.
+ *
+ * Return values:
+ *   TRILOGY_OK               - The value was parsed and the dereferenced value of
+ *                           `out` now points to it.
+ */
+int trilogy_reader_get_eof_buffer(trilogy_reader_t *reader, size_t *out_len, const void **out);
+
+/* trilogy_reader_eof - Check if the reader is at the end of the buffer.
+ *
+ * reader - A pointer to a pre-initialized trilogy_reader_t.
+ *
+ * Returns true if the reader is at the end of the buffer it's reading from,
+ * or false if not
+ */
+bool trilogy_reader_eof(trilogy_reader_t *reader);
+
+/* trilogy_reader_finish - Finalize the reader. This will ensure the entire buffer
+ * was parsed, otherwise TRILOGY_EXTRA_DATA_IN_PACKET will be returned.
+ *
+ * This can be useful to ensure an entire packet is fully read.
+ *
+ * reader  - A pointer to a pre-initialized trilogy_reader_t.
+ *
+ * Return values:
+ *   TRILOGY_OK                   - The entire buffer was parsed.
+ *   TRILOGY_EXTRA_DATA_IN_PACKET - There are unparsed bytes left in the buffer.
+ */
+int trilogy_reader_finish(trilogy_reader_t *reader);
+
+#endif

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

@@ -0,0 +1,111 @@
+#ifndef TRILOGY_SOCKET_H
+#define TRILOGY_SOCKET_H
+
+#include "trilogy/error.h"
+#include "trilogy/protocol.h"
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#include <openssl/x509v3.h>
+#include <stdbool.h>
+#include <sys/time.h>
+
+typedef enum {
+    TRILOGY_WAIT_READ = 0,
+    TRILOGY_WAIT_WRITE = 1,
+    TRILOGY_WAIT_HANDSHAKE = 2,
+} trilogy_wait_t;
+
+// We use the most strict mode as value 1 so if anyone ever
+// treats this as a boolean, they get the most strict behavior
+// by default.
+typedef enum {
+    TRILOGY_SSL_DISABLED = 0,
+    TRILOGY_SSL_VERIFY_IDENTITY = 1,
+    TRILOGY_SSL_VERIFY_CA = 2,
+    TRILOGY_SSL_REQUIRED_NOVERIFY = 3,
+    TRILOGY_SSL_PREFERRED_NOVERIFY = 4,
+} trilogy_ssl_mode_t;
+
+typedef enum {
+    TRILOGY_TLS_VERSION_UNDEF = 0,
+    TRILOGY_TLS_VERSION_10 = 1,
+    TRILOGY_TLS_VERSION_11 = 2,
+    TRILOGY_TLS_VERSION_12 = 3,
+    TRILOGY_TLS_VERSION_13 = 4,
+} trilogy_tls_version_t;
+
+typedef struct {
+    char *hostname;
+    char *path;
+    char *database;
+    char *username;
+    char *password;
+    size_t password_len;
+
+    trilogy_ssl_mode_t ssl_mode;
+    trilogy_tls_version_t tls_min_version;
+    trilogy_tls_version_t tls_max_version;
+    uint16_t port;
+
+    char *ssl_ca;
+    char *ssl_capath;
+    char *ssl_cert;
+    char *ssl_cipher;
+    char *ssl_crl;
+    char *ssl_crlpath;
+    char *ssl_key;
+    char *tls_ciphersuites;
+
+    struct timeval connect_timeout;
+    struct timeval read_timeout;
+    struct timeval write_timeout;
+
+    bool keepalive_enabled;
+    uint16_t keepalive_idle;
+    uint16_t keepalive_count;
+    uint16_t keepalive_interval;
+
+    TRILOGY_CAPABILITIES_t flags;
+} trilogy_sockopt_t;
+
+typedef struct trilogy_sock_t {
+    int (*connect_cb)(struct trilogy_sock_t *self);
+    ssize_t (*read_cb)(struct trilogy_sock_t *self, void *buf, size_t nread);
+    ssize_t (*write_cb)(struct trilogy_sock_t *self, const void *buf, size_t nwrite);
+    int (*wait_cb)(struct trilogy_sock_t *self, trilogy_wait_t wait);
+    int (*shutdown_cb)(struct trilogy_sock_t *self);
+    int (*close_cb)(struct trilogy_sock_t *self);
+    int (*fd_cb)(struct trilogy_sock_t *self);
+
+    trilogy_sockopt_t opts;
+} trilogy_sock_t;
+
+static inline int trilogy_sock_connect(trilogy_sock_t *sock) { return sock->connect_cb(sock); }
+
+static inline ssize_t trilogy_sock_read(trilogy_sock_t *sock, void *buf, size_t n)
+{
+    return sock->read_cb(sock, buf, n);
+}
+
+static inline ssize_t trilogy_sock_write(trilogy_sock_t *sock, const void *buf, size_t n)
+{
+    return sock->write_cb(sock, buf, n);
+}
+
+static inline int trilogy_sock_wait(trilogy_sock_t *sock, trilogy_wait_t wait) { return sock->wait_cb(sock, wait); }
+
+static inline int trilogy_sock_wait_read(trilogy_sock_t *sock) { return sock->wait_cb(sock, TRILOGY_WAIT_READ); }
+
+static inline int trilogy_sock_wait_write(trilogy_sock_t *sock) { return sock->wait_cb(sock, TRILOGY_WAIT_WRITE); }
+
+static inline int trilogy_sock_shutdown(trilogy_sock_t *sock) { return sock->shutdown_cb(sock); }
+
+static inline int trilogy_sock_close(trilogy_sock_t *sock) { return sock->close_cb(sock); }
+
+static inline int trilogy_sock_fd(trilogy_sock_t *sock) { return sock->fd_cb(sock); }
+
+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);
+
+#endif

data/ext/trilogy-ruby/inc/trilogy/vendor/curl_hostcheck.h

@@ -0,0 +1,29 @@
+#ifndef HEADER_CURL_HOSTCHECK_H
+#define HEADER_CURL_HOSTCHECK_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2012, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+#define CURL_HOST_NOMATCH 0
+#define CURL_HOST_MATCH 1
+int Curl_cert_hostcheck(const char *match_pattern, const char *hostname);
+
+#endif /* HEADER_CURL_HOSTCHECK_H */

data/ext/trilogy-ruby/inc/trilogy/vendor/openssl_hostname_validation.h

@@ -0,0 +1,51 @@
+#ifndef HEADER_OPENSSL_HOSTNAME_VALIDATION_H
+#define HEADER_OPENSSL_HOSTNAME_VALIDATION_H
+/* Obtained from: https://github.com/iSECPartners/ssl-conservatory */
+
+/*
+Copyright (C) 2012, iSEC Partners.
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+/*
+ * Helper functions to perform basic hostname validation using OpenSSL.
+ *
+ * Please read "everything-you-wanted-to-know-about-openssl.pdf" before
+ * attempting to use this code. This whitepaper describes how the code works,
+ * how it should be used, and what its limitations are.
+ *
+ * Author:  Alban Diquet
+ * License: See LICENSE
+ *
+ */
+
+typedef enum { MatchFound, MatchNotFound, NoSANPresent, MalformedCertificate, Error } HostnameValidationResult;
+
+/**
+ * Validates the server's identity by looking for the expected hostname in the
+ * server's certificate. As described in RFC 6125, it first tries to find a
+ * match in the Subject Alternative Name extension. If the extension is not
+ * present in the certificate, it checks the Common Name instead.
+ *
+ * Returns MatchFound if a match was found.
+ * Returns MatchNotFound if no matches were found.
+ * Returns MalformedCertificate if any of the hostnames had a NUL character
+ * embedded in it. Returns Error if there was an error.
+ */
+HostnameValidationResult validate_hostname(const char *hostname, const X509 *server_cert);
+
+#endif /* HEADER_OPENSSL_HOSTNAME_VALIDATION_H */

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

@@ -0,0 +1,8 @@
+#ifndef TRILOGY_H
+#define TRILOGY_H
+
+#include "trilogy/blocking.h"
+#include "trilogy/client.h"
+#include "trilogy/error.h"
+
+#endif

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

@@ -0,0 +1,241 @@
+#include <errno.h>
+#include <poll.h>
+
+#include "trilogy/blocking.h"
+#include "trilogy/client.h"
+#include "trilogy/error.h"
+
+#define CHECKED(expr)                                                                                                  \
+    if ((rc = (expr)) < 0) {                                                                                           \
+        return rc;                                                                                                     \
+    }
+
+static int flush_full(trilogy_conn_t *conn)
+{
+    int rc;
+
+    while (1) {
+        CHECKED(trilogy_sock_wait_write(conn->socket));
+
+        rc = trilogy_flush_writes(conn);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+    }
+}
+
+static int trilogy_connect_auth_switch(trilogy_conn_t *conn, trilogy_handshake_t *handshake)
+{
+    int rc = trilogy_auth_switch_send(conn, handshake);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_auth_recv(conn, handshake);
+
+        if (rc != TRILOGY_AGAIN) {
+            break;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+    return rc;
+}
+
+static int trilogy_connect_handshake(trilogy_conn_t *conn)
+{
+    trilogy_handshake_t handshake;
+    int rc;
+
+    while (1) {
+        rc = trilogy_connect_recv(conn, &handshake);
+
+        if (rc == TRILOGY_OK) {
+            break;
+        }
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+
+    rc = trilogy_auth_send(conn, &handshake);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_auth_recv(conn, &handshake);
+
+        if (rc != TRILOGY_AGAIN) {
+            break;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+
+    if (rc == TRILOGY_AUTH_SWITCH) {
+        return trilogy_connect_auth_switch(conn, &handshake);
+    }
+    return rc;
+}
+
+int trilogy_connect(trilogy_conn_t *conn, const trilogy_sockopt_t *opts)
+{
+    int rc = trilogy_connect_send(conn, opts);
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    return trilogy_connect_handshake(conn);
+}
+
+int trilogy_connect_sock(trilogy_conn_t *conn, trilogy_sock_t *sock)
+{
+    int rc = trilogy_connect_send_socket(conn, sock);
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    return trilogy_connect_handshake(conn);
+}
+
+int trilogy_change_db(trilogy_conn_t *conn, const char *name, size_t name_len)
+{
+    int rc = trilogy_change_db_send(conn, name, name_len);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_change_db_recv(conn);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+int trilogy_ping(trilogy_conn_t *conn)
+{
+    int rc = trilogy_ping_send(conn);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_ping_recv(conn);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+int trilogy_query(trilogy_conn_t *conn, const char *query, size_t query_len, uint64_t *column_count_out)
+{
+    int rc = trilogy_query_send(conn, query, query_len);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_query_recv(conn, column_count_out);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+int trilogy_read_full_column(trilogy_conn_t *conn, trilogy_column_t *column_out)
+{
+    int rc;
+
+    while (1) {
+        rc = trilogy_read_column(conn, column_out);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+int trilogy_read_full_row(trilogy_conn_t *conn, trilogy_value_t *values_out)
+{
+    int rc;
+
+    while (1) {
+        rc = trilogy_read_row(conn, values_out);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+int trilogy_close(trilogy_conn_t *conn)
+{
+    int rc = trilogy_close_send(conn);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_close_recv(conn);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+#undef CHECKED