trilogy 2.9.0 → 2.12.4

data/ext/trilogy-ruby/extconf.rb

@@ -10,12 +10,24 @@ File.binwrite("trilogy.c",
   }.join)
 
 $objs = %w[trilogy.o cast.o cext.o]
-$CFLAGS << " -I #{__dir__}/inc -std=gnu99 -fvisibility=hidden"
+append_cflags([
+  # Ref: https://github.com/trilogy-libraries/trilogy/issues/290
+  # Fix build on older ruby versions and Xcode 26.4+
+  "-Wno-default-const-init-field-unsafe",
 
-dir_config("openssl")
+  "-I#{__dir__}/inc",
+  "-std=gnu99",
+  "-fvisibility=hidden",
+  "-DTRILOGY_XALLOCATOR",
+  "-g",
+])
+
+dir_config("openssl").any? || pkg_config("openssl")
 
 have_library("crypto", "CRYPTO_malloc")
 have_library("ssl", "SSL_new")
-have_func("rb_interned_str", "ruby.h")
+have_func("rb_ractor_local_storage_value_newkey", "ruby.h")
+have_func("rb_enc_interned_str", "ruby.h")
+have_func("rb_io_descriptor", "ruby.h") # Ruby 3.1+
 
 create_makefile "trilogy/cext"

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

@@ -0,0 +1,61 @@
+#ifndef TRILOGY_INTERNAL_ALLOCATOR_H
+#define TRILOGY_INTERNAL_ALLOCATOR_H
+
+/* If you build Trilogy with a custom allocator, configure it with
+ * "-D TRILOGY_XALLOCATOR" to use your own allocator that defines xmalloc,
+ * xrealloc, xcalloc, and xfree.
+ *
+ * For example, your `trilogy_xallocator.h` file could look like this:
+ *
+ * ```
+ * #ifndef TRILOGY_XALLOCATOR_H
+ * #define TRILOGY_XALLOCATOR_H
+ * #define xmalloc          my_malloc
+ * #define xrealloc         my_realloc
+ * #define xcalloc          my_calloc
+ * #define xfree            my_free
+ * #endif
+ * ```
+ */
+#ifdef TRILOGY_XALLOCATOR
+    #include "trilogy_xallocator.h"
+#else
+    #ifndef xmalloc
+        /* The malloc function that should be used. This can be overridden with
+         * the TRILOGY_XALLOCATOR define. */
+        #define xmalloc malloc
+    #endif
+
+    #ifndef xrealloc
+        /* The realloc function that should be used. This can be overridden with
+         * the TRILOGY_XALLOCATOR define. */
+        #define xrealloc realloc
+    #endif
+
+    #ifndef xcalloc
+        /* The calloc function that should be used. This can be overridden with
+         * the TRILOGY_XALLOCATOR define. */
+        #define xcalloc calloc
+    #endif
+
+    #ifndef xfree
+        /* The free function that should be used. This can be overridden with
+         * the TRILOGY_XALLOCATOR define. */
+        #define xfree free
+    #endif
+#endif
+
+#include <string.h>
+static inline char *
+xstrdup(const char *str)
+{
+    char *tmp;
+    size_t len = strlen(str) + 1;
+
+    tmp = xmalloc(len);
+    memcpy(tmp, str, len);
+
+    return tmp;
+}
+
+#endif

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

@@ -53,6 +53,19 @@ int trilogy_buffer_expand(trilogy_buffer_t *buffer, size_t needed);
  */
 int trilogy_buffer_putc(trilogy_buffer_t *buffer, uint8_t c);
 
+/* trilogy_buffer_write - Appends multiple bytes to the buffer, resizing the underlying
+ * allocation if necessary.
+ *
+ * buffer - A pointer to a pre-initialized trilogy_buffer_t.
+ * ptr    - The pointer to the byte array.
+ * len    - How many bytes to append.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The character was appended to the buffer
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_buffer_write(trilogy_buffer_t *buffer, const uint8_t *ptr, size_t len);
+
 /* trilogy_buffer_free - Free an trilogy_buffer_t's underlying storage. The buffer
  * must be re-initialized with trilogy_buffer_init if it is to be reused. Any
  * operations performed on an unintialized or freed buffer are undefined.

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

@@ -106,6 +106,15 @@ typedef struct {
  */
 int trilogy_init(trilogy_conn_t *conn);
 
+/* trilogy_init_no_buffer - Same as trilogy_init but doesn't allocate the packet buffer
+ *
+ * conn - A pre-allocated trilogy_conn_t pointer.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The trilogy_conn_t pointer was properly initialized
+ */
+int trilogy_init_no_buffer(trilogy_conn_t *conn);
+
 /* trilogy_flush_writes - Attempt to flush the internal packet buffer to the
  * network. This must be used if a `_send` function returns TRILOGY_AGAIN, and
  * should continue to be called until it returns a value other than
@@ -150,6 +159,8 @@ int trilogy_connect_send(trilogy_conn_t *conn, const trilogy_sockopt_t *opts);
  */
 int trilogy_connect_send_socket(trilogy_conn_t *conn, trilogy_sock_t *sock);
 
+int trilogy_connect_set_fd(trilogy_conn_t *conn, trilogy_sock_t *sock, int fd);
+
 /* trilogy_connect_recv - Read the initial handshake from the server.
  *
  * This should be called after trilogy_connect_send returns TRILOGY_OK. Calling

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

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

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

@@ -88,6 +88,8 @@ typedef struct trilogy_sock_t {
 
 static inline int trilogy_sock_connect(trilogy_sock_t *sock) { return sock->connect_cb(sock); }
 
+void trilogy_sock_set_fd(trilogy_sock_t *sock, int fd);
+
 static inline ssize_t trilogy_sock_read(trilogy_sock_t *sock, void *buf, size_t n)
 {
     return sock->read_cb(sock, buf, n);

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

@@ -1,6 +1,7 @@
 #ifndef TRILOGY_H
 #define TRILOGY_H
 
+#include "trilogy/allocator.h"
 #include "trilogy/blocking.h"
 #include "trilogy/client.h"
 #include "trilogy/error.h"

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

@@ -1,6 +1,8 @@
 #include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
 
+#include "trilogy/allocator.h"
 #include "trilogy/buffer.h"
 #include "trilogy/error.h"
 
@@ -8,7 +10,7 @@ int trilogy_buffer_init(trilogy_buffer_t *buffer, size_t initial_capacity)
 {
     buffer->len = 0;
     buffer->cap = initial_capacity;
-    buffer->buff = malloc(initial_capacity);
+    buffer->buff = xmalloc(initial_capacity);
 
     if (buffer->buff == NULL) {
         return TRILOGY_SYSERR;
@@ -23,6 +25,9 @@ int trilogy_buffer_expand(trilogy_buffer_t *buffer, size_t needed)
 {
     // expand buffer if necessary
     if (buffer->len + needed > buffer->cap) {
+        if (buffer->buff == NULL)
+            return TRILOGY_MEM_ERROR;
+
         size_t new_cap = buffer->cap;
 
         while (buffer->len + needed > new_cap) {
@@ -33,7 +38,7 @@ int trilogy_buffer_expand(trilogy_buffer_t *buffer, size_t needed)
             new_cap *= EXPAND_MULTIPLIER;
         }
 
-        uint8_t *new_buff = realloc(buffer->buff, new_cap);
+        uint8_t *new_buff = xrealloc(buffer->buff, new_cap);
         if (new_buff == NULL)
             return TRILOGY_SYSERR;
 
@@ -57,9 +62,24 @@ int trilogy_buffer_putc(trilogy_buffer_t *buffer, uint8_t c)
     return TRILOGY_OK;
 }
 
+int trilogy_buffer_write(trilogy_buffer_t *buffer, const uint8_t *ptr, size_t len)
+{
+    int rc = trilogy_buffer_expand(buffer, len);
+    if (rc) {
+        return rc;
+    }
+
+    memcpy(buffer->buff + buffer->len, ptr, len);
+    buffer->len += len;
+
+    return TRILOGY_OK;
+}
+
 void trilogy_buffer_free(trilogy_buffer_t *buffer)
 {
-    free(buffer->buff);
-    buffer->buff = NULL;
-    buffer->len = buffer->cap = 0;
+    if (buffer->buff) {
+        xfree(buffer->buff);
+        buffer->buff = NULL;
+        buffer->len = buffer->cap = 0;
+    }
 }