nng 0.1.0 → 1.0.1

data/ext/rbnng/socket.c

@@ -1,126 +1,696 @@
-/*
- * Copyright (c) 2021 Adib Saad
- *
- */
-#include "socket.h"
-#include "msg.h"
 #include "rbnng.h"
-#include <ruby.h>
-#include <ruby/thread.h>
+
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <nng/protocol/bus0/bus.h>
+#include <nng/protocol/pair0/pair.h>
+#include <nng/protocol/pair1/pair.h>
+#include <nng/protocol/pubsub0/pub.h>
+#include <nng/protocol/pubsub0/sub.h>
+#include <nng/protocol/pipeline0/pull.h>
+#include <nng/protocol/pipeline0/push.h>
+#include <nng/protocol/reqrep0/rep.h>
+#include <nng/protocol/reqrep0/req.h>
+#include <nng/protocol/survey0/respond.h>
+#include <nng/protocol/survey0/survey.h>
+
+/* ── TypedData ──────────────────────────────────────────────────── */
 
 static void
-socket_free(void* ptr)
+socket_free(void *ptr)
 {
-  RbnngSocket* p_rbnngSocket = (RbnngSocket*)ptr;
-  nng_close(p_rbnngSocket->socket);
-  xfree(p_rbnngSocket);
+    rbnng_socket_t *s = ptr;
+    if (s->initialized)
+        nng_close(s->socket);
+    if (s->notify_fds[0] >= 0) close(s->notify_fds[0]);
+    if (s->notify_fds[1] >= 0) close(s->notify_fds[1]);
+    xfree(s);
 }
 
-VALUE
+static size_t
+socket_memsize(const void *ptr)
+{
+    return sizeof(rbnng_socket_t);
+}
+
+const rb_data_type_t rbnng_socket_type = {
+    .wrap_struct_name = "NNG::Socket::Base",
+    .function = {
+        .dmark  = NULL,
+        .dfree  = socket_free,
+        .dsize  = socket_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
 socket_alloc(VALUE klass)
 {
-  RbnngSocket* p_rbnngSocket = ZALLOC(RbnngSocket);
-  return rb_data_object_wrap(klass, p_rbnngSocket, 0, socket_free);
+    rbnng_socket_t *s;
+    VALUE obj = TypedData_Make_Struct(klass, rbnng_socket_t, &rbnng_socket_type, s);
+    s->notify_fds[0] = -1;
+    s->notify_fds[1] = -1;
+    return obj;
 }
 
-void*
-socket_get_msg_blocking(RbnngSocket* p_rbnngSocket)
+static inline rbnng_socket_t *
+socket_get(VALUE self)
 {
-  nng_msg* p_msg = NULL;
-  int rv;
-  if ((rv = nng_recvmsg(p_rbnngSocket->socket, &p_msg, 0)) != 0) {
-    return rv;
-  }
+    rbnng_socket_t *s;
+    TypedData_Get_Struct(self, rbnng_socket_t, &rbnng_socket_type, s);
+    if (!s->initialized)
+        rb_raise(rb_eRuntimeError, "socket not initialized");
+    return s;
+}
+
+/* ── GVL release helpers ────────────────────────────────────────── */
+
+typedef struct {
+    nng_socket socket;
+    nng_msg   *msg;
+    int        rv;
+} recv_args_t;
 
-  p_rbnngSocket->p_getMsgResult = p_msg;
-  return 0;
+static void *
+recv_without_gvl(void *arg)
+{
+    recv_args_t *a = arg;
+    a->msg = NULL;
+    a->rv = nng_recvmsg(a->socket, &a->msg, 0);
+    return NULL;
 }
 
-VALUE
-socket_get_msg(VALUE self)
+typedef struct {
+    nng_socket  socket;
+    nng_msg    *msg;
+    int         rv;
+} send_args_t;
+
+static void *
+send_without_gvl(void *arg)
 {
-  RbnngSocket* p_rbnngSocket;
-  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+    send_args_t *a = arg;
+    a->rv = nng_sendmsg(a->socket, a->msg, 0);
+    return NULL;
+}
 
-  int rv =
-    rb_thread_call_without_gvl(socket_get_msg_blocking, p_rbnngSocket, 0, 0);
+/* ── Shared methods (defined on Base) ───────────────────────────── */
 
-  if (rv == 0) {
-    RbnngMsg* p_newMsg;
-    VALUE newMsg = rb_class_new_instance(0, 0, rbnng_MsgClass);
-    Data_Get_Struct(newMsg, RbnngMsg, p_newMsg);
-    p_newMsg->p_msg = p_rbnngSocket->p_getMsgResult;
-    return newMsg;
-  } else {
-    raise_error(rv);
+static VALUE
+socket_close(VALUE self)
+{
+    rbnng_socket_t *s = socket_get(self);
+    int rv = nng_close(s->socket);
+    if (rv != 0)
+        raise_nng_error(rv);
     return Qnil;
-  }
 }
 
-void*
-socket_send_msg_blocking(void* data)
+static VALUE
+socket_listen(VALUE self, VALUE url)
 {
-  RbnngSendMsgReq* p_sendMsgReq = (RbnngSendMsgReq*)data;
-  RbnngSocket* p_rbnngSocket;
-  Data_Get_Struct(p_sendMsgReq->socketObj, RbnngSocket, p_rbnngSocket);
-  int rv;
-  nng_msg* p_msg;
-  if ((rv = nng_msg_alloc(&p_msg, 0)) != 0) {
-    return rv;
-  }
+    rbnng_socket_t *s = socket_get(self);
+    nng_listener lp;
+    int rv = nng_listen(s->socket, StringValueCStr(url), &lp, 0);
+    if (rv != 0)
+        raise_nng_error(rv);
 
-  rv = nng_msg_append(p_msg,
-                      StringValuePtr(p_sendMsgReq->nextMsg),
-                      RSTRING_LEN(p_sendMsgReq->nextMsg));
-  if (rv != 0) {
-    return rv;
-  }
+    /* Try to get the resolved URL from the listener (e.g. tcp://host:0 → actual port) */
+    char *resolved;
+    rv = nng_listener_get_string(lp, NNG_OPT_URL, &resolved);
+    if (rv == 0) {
+        int is_abstract_auto = (strcmp(resolved, "abstract://") == 0);
+        VALUE result = rb_str_new_cstr(resolved);
+        nng_strfree(resolved);
 
-  // nng_sendmsg takes ownership of p_msg, so no need to free it afterwards.
-  if ((rv = nng_sendmsg(p_rbnngSocket->socket, p_msg, 0)) != 0) {
-    return rv;
-  }
+        /* For abstract:// with auto-generated name, the URL stays "abstract://"
+         * but the actual name is in LOCADDR */
+        if (is_abstract_auto) {
+            nng_sockaddr sa;
+            rv = nng_listener_get_addr(lp, NNG_OPT_LOCADDR, &sa);
+            if (rv == 0 && sa.s_family == NNG_AF_ABSTRACT && sa.s_abstract.sa_len > 0) {
+                char buf[128];
+                int n = snprintf(buf, sizeof(buf), "abstract://%.*s",
+                                 (int)sa.s_abstract.sa_len,
+                                 (const char *)sa.s_abstract.sa_name);
+                return rb_str_new(buf, n);
+            }
+        }
 
-  return 0;
+        return result;
+    }
+    return Qnil;
 }
 
-VALUE
-socket_send_msg(VALUE self, VALUE rb_strMsg)
+static VALUE
+socket_dial(VALUE self, VALUE url)
 {
-  Check_Type(rb_strMsg, T_STRING);
-  RbnngSendMsgReq sendMsgReq = {
-    .socketObj = self,
-    .nextMsg = rb_strMsg,
-  };
-  int rv =
-    rb_thread_call_without_gvl(socket_send_msg_blocking, &sendMsgReq, 0, 0);
-  if (rv != 0) {
-    raise_error(rv);
-  }
+    rbnng_socket_t *s = socket_get(self);
+    int rv = nng_dial(s->socket, StringValueCStr(url), NULL, 0);
+    if (rv != 0)
+        raise_nng_error(rv);
+    return Qnil;
 }
 
-VALUE
-socket_dial(VALUE self, VALUE url)
+/* _listen_tls(url, cert_pem, key_pem, ca_pem, verify, server_name) */
+static VALUE
+socket_listen_tls(VALUE self, VALUE url, VALUE cert_pem, VALUE key_pem,
+                  VALUE ca_pem, VALUE verify, VALUE server_name)
 {
-  Check_Type(url, T_STRING);
-  RbnngSocket* p_rbnngSocket;
-  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
-  int rv;
-  if ((rv = nng_dial(p_rbnngSocket->socket, StringValueCStr(url), 0, 0)) != 0) {
-    raise_error(rv);
-  }
+    rbnng_socket_t *s = socket_get(self);
+    rbnng_tls_listen(s->socket, StringValueCStr(url),
+                     cert_pem, key_pem, ca_pem,
+                     RTEST(verify), server_name);
+    return Qnil;
 }
 
-VALUE
-socket_listen(VALUE self, VALUE url)
+/* _dial_tls(url, cert_pem, key_pem, ca_pem, verify, server_name) */
+static VALUE
+socket_dial_tls(VALUE self, VALUE url, VALUE cert_pem, VALUE key_pem,
+                VALUE ca_pem, VALUE verify, VALUE server_name)
+{
+    rbnng_socket_t *s = socket_get(self);
+    rbnng_tls_dial(s->socket, StringValueCStr(url),
+                   cert_pem, key_pem, ca_pem,
+                   RTEST(verify), server_name);
+    return Qnil;
+}
+
+static VALUE
+socket_receive(VALUE self)
+{
+    rbnng_socket_t *s = socket_get(self);
+    nng_msg *msg = NULL;
+
+    /* Fast path: try non-blocking (no GVL release needed) */
+    int rv = nng_recvmsg(s->socket, &msg, NNG_FLAG_NONBLOCK);
+    if (rv == 0)
+        return rbnng_msg_wrap(msg);
+
+    if (rv != NNG_EAGAIN)
+        raise_nng_error(rv);
+
+    /* Slow path: nothing ready, release GVL and block */
+    recv_args_t args;
+    args.socket = s->socket;
+
+    rb_thread_call_without_gvl(recv_without_gvl, &args, RUBY_UBF_IO, NULL);
+
+    if (args.rv != 0)
+        raise_nng_error(args.rv);
+    return rbnng_msg_wrap(args.msg);
+}
+
+static VALUE
+socket_send(VALUE self, VALUE data)
+{
+    rbnng_socket_t *s = socket_get(self);
+    StringValue(data);
+
+    nng_msg *msg;
+    int rv = nng_msg_alloc(&msg, 0);
+    if (rv != 0)
+        raise_nng_error(rv);
+
+    rv = nng_msg_append(msg, RSTRING_PTR(data), RSTRING_LEN(data));
+    if (rv != 0) {
+        nng_msg_free(msg);
+        raise_nng_error(rv);
+    }
+
+    /* Fast path: try non-blocking (no GVL release needed) */
+    rv = nng_sendmsg(s->socket, msg, NNG_FLAG_NONBLOCK);
+    if (rv == 0)
+        return Qnil;
+
+    if (rv != NNG_EAGAIN) {
+        nng_msg_free(msg);
+        raise_nng_error(rv);
+    }
+
+    /* Slow path: socket not ready, release GVL and block */
+    send_args_t args;
+    args.socket = s->socket;
+    args.msg = msg;
+
+    rb_thread_call_without_gvl(send_without_gvl, &args, RUBY_UBF_IO, NULL);
+
+    if (args.rv != 0) {
+        nng_msg_free(msg);
+        raise_nng_error(args.rv);
+    }
+    return Qnil;
+}
+
+static VALUE
+socket_forward(VALUE self, VALUE msg_obj)
+{
+    rbnng_socket_t *s = socket_get(self);
+    rbnng_msg_t *m;
+    TypedData_Get_Struct(msg_obj, rbnng_msg_t, &rbnng_msg_type, m);
+
+    if (!m->msg)
+        rb_raise(rb_eRuntimeError, "message already consumed");
+
+    nng_msg *raw_msg = m->msg;
+    m->msg = NULL; /* consume */
+
+    send_args_t args;
+    args.socket = s->socket;
+    args.msg = raw_msg;
+
+    rb_thread_call_without_gvl(send_without_gvl, &args, RUBY_UBF_IO, NULL);
+
+    if (args.rv != 0) {
+        nng_msg_free(raw_msg);
+        raise_nng_error(args.rv);
+    }
+    return Qnil;
+}
+
+static VALUE
+socket_recv_fd(VALUE self)
+{
+    rbnng_socket_t *s = socket_get(self);
+    int fd;
+    int rv = nng_socket_get_int(s->socket, NNG_OPT_RECVFD, &fd);
+    if (rv != 0)
+        raise_nng_error(rv);
+    return INT2FIX(fd);
+}
+
+static VALUE
+socket_send_fd(VALUE self)
 {
-  Check_Type(url, T_STRING);
-  RbnngSocket* p_rbnngSocket;
-  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+    rbnng_socket_t *s = socket_get(self);
+    int fd;
+    int rv = nng_socket_get_int(s->socket, NNG_OPT_SENDFD, &fd);
+    if (rv != 0)
+        raise_nng_error(rv);
+    return INT2FIX(fd);
+}
+
+/* ── Option getters/setters ─────────────────────────────────────── */
+
+static VALUE
+socket_get_opt_int(VALUE self, VALUE name)
+{
+    rbnng_socket_t *s = socket_get(self);
+    int val;
+    int rv = nng_socket_get_int(s->socket, StringValueCStr(name), &val);
+    if (rv != 0)
+        raise_nng_error(rv);
+    return INT2NUM(val);
+}
+
+static VALUE
+socket_set_opt_int(VALUE self, VALUE name, VALUE val)
+{
+    rbnng_socket_t *s = socket_get(self);
+    int rv = nng_socket_set_int(s->socket, StringValueCStr(name), NUM2INT(val));
+    if (rv != 0)
+        raise_nng_error(rv);
+    return Qnil;
+}
+
+static VALUE
+socket_get_opt_ms(VALUE self, VALUE name)
+{
+    rbnng_socket_t *s = socket_get(self);
+    nng_duration val;
+    int rv = nng_socket_get_ms(s->socket, StringValueCStr(name), &val);
+    if (rv != 0)
+        raise_nng_error(rv);
+    return INT2NUM(val);
+}
+
+static VALUE
+socket_set_opt_ms(VALUE self, VALUE name, VALUE val)
+{
+    rbnng_socket_t *s = socket_get(self);
+    int rv = nng_socket_set_ms(s->socket, StringValueCStr(name), NUM2INT(val));
+    if (rv != 0)
+        raise_nng_error(rv);
+    return Qnil;
+}
+
+static VALUE
+socket_get_opt_size(VALUE self, VALUE name)
+{
+    rbnng_socket_t *s = socket_get(self);
+    size_t val;
+    int rv = nng_socket_get_size(s->socket, StringValueCStr(name), &val);
+    if (rv != 0)
+        raise_nng_error(rv);
+    return SIZET2NUM(val);
+}
+
+static VALUE
+socket_set_opt_size(VALUE self, VALUE name, VALUE val)
+{
+    rbnng_socket_t *s = socket_get(self);
+    int rv = nng_socket_set_size(s->socket, StringValueCStr(name), NUM2SIZET(val));
+    if (rv != 0)
+        raise_nng_error(rv);
+    return Qnil;
+}
+
+static VALUE
+socket_get_opt_string(VALUE self, VALUE name)
+{
+    rbnng_socket_t *s = socket_get(self);
+    char *val;
+    int rv = nng_socket_get_string(s->socket, StringValueCStr(name), &val);
+    if (rv != 0)
+        raise_nng_error(rv);
+    VALUE str = rb_str_new_cstr(val);
+    nng_strfree(val);
+    return str;
+}
+
+static VALUE
+socket_set_opt_string(VALUE self, VALUE name, VALUE val)
+{
+    rbnng_socket_t *s = socket_get(self);
+    int rv = nng_socket_set_string(s->socket, StringValueCStr(name),
+                                   StringValueCStr(val));
+    if (rv != 0)
+        raise_nng_error(rv);
+    return Qnil;
+}
+
+/* ── Protocol initializers ──────────────────────────────────────── */
+
+typedef struct {
+    int raw;
+    VALUE timeout;
+} init_kwargs_t;
+
+static init_kwargs_t
+parse_init_kwargs(int argc, VALUE *argv)
+{
+    init_kwargs_t kw = { .raw = 0, .timeout = Qnil };
+    VALUE opts = Qnil;
+    rb_scan_args(argc, argv, ":", &opts);
+    if (!NIL_P(opts)) {
+        kw.raw = RTEST(rb_hash_lookup2(opts, ID2SYM(rb_intern("raw")), Qfalse));
+        kw.timeout = rb_hash_lookup2(opts, ID2SYM(rb_intern("timeout")), Qnil);
+    }
+    return kw;
+}
+
+static void
+apply_timeout(nng_socket socket, VALUE timeout)
+{
+    if (NIL_P(timeout)) return;
+
+    int ms = (int)(NUM2DBL(timeout) * 1000);
+    int rv;
+    rv = nng_socket_set_ms(socket, NNG_OPT_RECVTIMEO, ms);
+    if (rv != 0) raise_nng_error(rv);
+    rv = nng_socket_set_ms(socket, NNG_OPT_SENDTIMEO, ms);
+    if (rv != 0) raise_nng_error(rv);
+}
+
+#define DEF_INIT(name, open_fn, open_raw_fn)                          \
+    static VALUE                                                      \
+    name(int argc, VALUE *argv, VALUE self)                           \
+    {                                                                 \
+        rbnng_socket_t *s;                                            \
+        TypedData_Get_Struct(self, rbnng_socket_t,                    \
+                             &rbnng_socket_type, s);                  \
+        if (s->initialized)                                           \
+            rb_raise(rb_eRuntimeError, "socket already initialized"); \
+        init_kwargs_t kw = parse_init_kwargs(argc, argv);             \
+        int rv = kw.raw ? open_raw_fn(&s->socket)                    \
+                        : open_fn(&s->socket);                        \
+        if (rv != 0)                                                  \
+            raise_nng_error(rv);                                      \
+        s->initialized = 1;                                           \
+        rb_ivar_set(self, rb_intern("@raw"), kw.raw ? Qtrue : Qfalse);\
+        apply_timeout(s->socket, kw.timeout);                         \
+        return self;                                                  \
+    }
+
+DEF_INIT(pair0_init,      nng_pair0_open,      nng_pair0_open_raw)
+DEF_INIT(pair1_init,      nng_pair1_open,      nng_pair1_open_raw)
+DEF_INIT(bus0_init_inner, nng_bus0_open,        nng_bus0_open_raw)
+DEF_INIT(pub0_init,       nng_pub0_open,        nng_pub0_open_raw)
+DEF_INIT(sub0_init_inner, nng_sub0_open,        nng_sub0_open_raw)
+DEF_INIT(push0_init,      nng_push0_open,       nng_push0_open_raw)
+DEF_INIT(pull0_init,      nng_pull0_open,       nng_pull0_open_raw)
+DEF_INIT(req0_init,       nng_req0_open,        nng_req0_open_raw)
+DEF_INIT(rep0_init,       nng_rep0_open,        nng_rep0_open_raw)
+DEF_INIT(surveyor0_init,  nng_surveyor0_open,   nng_surveyor0_open_raw)
+DEF_INIT(respondent0_init,nng_respondent0_open, nng_respondent0_open_raw)
+
+/* Sub0: subscribe with optional prefix: kwarg (default: subscribe to all) */
+static VALUE
+sub0_init(int argc, VALUE *argv, VALUE self)
+{
+    rbnng_socket_t *s;
+    TypedData_Get_Struct(self, rbnng_socket_t, &rbnng_socket_type, s);
+    if (s->initialized)
+        rb_raise(rb_eRuntimeError, "socket already initialized");
+
+    VALUE opts = Qnil;
+    rb_scan_args(argc, argv, ":", &opts);
+
+    int raw = 0;
+    VALUE prefix = Qnil;
+    VALUE timeout = Qnil;
+    if (!NIL_P(opts)) {
+        raw = RTEST(rb_hash_lookup2(opts, ID2SYM(rb_intern("raw")), Qfalse));
+        prefix = rb_hash_lookup2(opts, ID2SYM(rb_intern("prefix")), Qnil);
+        timeout = rb_hash_lookup2(opts, ID2SYM(rb_intern("timeout")), Qnil);
+    }
+
+    int rv = raw ? nng_sub0_open_raw(&s->socket)
+                 : nng_sub0_open(&s->socket);
+    if (rv != 0)
+        raise_nng_error(rv);
+    s->initialized = 1;
+    rb_ivar_set(self, rb_intern("@raw"), raw ? Qtrue : Qfalse);
+
+    if (NIL_P(prefix)) {
+        rv = nng_socket_set(s->socket, NNG_OPT_SUB_SUBSCRIBE, NULL, 0);
+    } else {
+        StringValue(prefix);
+        rv = nng_socket_set(s->socket, NNG_OPT_SUB_SUBSCRIBE,
+                            RSTRING_PTR(prefix), RSTRING_LEN(prefix));
+    }
+    if (rv != 0)
+        raise_nng_error(rv);
+
+    apply_timeout(s->socket, timeout);
+
+    return self;
+}
+
+/* Sub0: subscribe to a topic prefix at runtime */
+static VALUE
+sub0_subscribe(VALUE self, VALUE prefix)
+{
+    rbnng_socket_t *s = socket_get(self);
+    StringValue(prefix);
+    int rv = nng_socket_set(s->socket, NNG_OPT_SUB_SUBSCRIBE,
+                            RSTRING_PTR(prefix), RSTRING_LEN(prefix));
+    if (rv != 0)
+        raise_nng_error(rv);
+    return self;
+}
+
+/* Sub0: unsubscribe from a topic prefix */
+static VALUE
+sub0_unsubscribe(VALUE self, VALUE prefix)
+{
+    rbnng_socket_t *s = socket_get(self);
+    StringValue(prefix);
+    int rv = nng_socket_set(s->socket, NNG_OPT_SUB_UNSUBSCRIBE,
+                            RSTRING_PTR(prefix), RSTRING_LEN(prefix));
+    if (rv != 0)
+        raise_nng_error(rv);
+    return self;
+}
+
+/* ── Pipe notification ─────────────────────────────────────────── */
+
+/*
+ * Event packet written by the C callback (5 bytes):
+ *   byte 0:    event type  (1 = connect / ADD_POST, 2 = disconnect / REM_POST)
+ *   bytes 1-4: pipe id     (uint32 little-endian)
+ *
+ * The callback runs on an NNG internal thread with the socket lock held,
+ * so it cannot touch Ruby.  Writing to a pipe(2) is async-signal-safe.
+ */
+
+/* event packet: 1 byte event type + nng_pipe (uint32_t) */
+#define PIPE_EVENT_SIZE (1 + sizeof(nng_pipe))
+
+static void
+pipe_notify_cb(nng_pipe p, nng_pipe_ev ev, void *arg)
+{
+    rbnng_socket_t *s = arg;
+    if (s->notify_fds[1] < 0) return;
+
+    uint8_t buf[PIPE_EVENT_SIZE];
+    buf[0] = (ev == NNG_PIPE_EV_ADD_POST) ? 1 : 2;
+    memcpy(buf + 1, &p, sizeof(nng_pipe));
+
+    /* best-effort write; if the fd is full we drop the event */
+    (void)write(s->notify_fds[1], buf, PIPE_EVENT_SIZE);
+}
+
+static VALUE
+socket_pipe_notify_start(VALUE self)
+{
+    rbnng_socket_t *s = socket_get(self);
+    if (s->notify_fds[0] >= 0)
+        return INT2NUM(s->notify_fds[0]); /* already started */
+
+    int fds[2];
+    if (pipe(fds) < 0)
+        rb_sys_fail("pipe");
+
+    /* make both ends non-blocking:
+     * - write end: so the NNG callback never stalls
+     * - read end:  so recv_pipe_event returns nil immediately when empty */
+    int flags;
+    flags = fcntl(fds[0], F_GETFL);
+    if (flags < 0 || fcntl(fds[0], F_SETFL, flags | O_NONBLOCK) < 0) {
+        close(fds[0]);
+        close(fds[1]);
+        rb_sys_fail("fcntl");
+    }
+    flags = fcntl(fds[1], F_GETFL);
+    if (flags < 0 || fcntl(fds[1], F_SETFL, flags | O_NONBLOCK) < 0) {
+        close(fds[0]);
+        close(fds[1]);
+        rb_sys_fail("fcntl");
+    }
+
+    s->notify_fds[0] = fds[0];
+    s->notify_fds[1] = fds[1];
+
+    int rv;
+    rv = nng_pipe_notify(s->socket, NNG_PIPE_EV_ADD_POST, pipe_notify_cb, s);
+    if (rv != 0) {
+        close(s->notify_fds[0]);
+        close(s->notify_fds[1]);
+        s->notify_fds[0] = -1;
+        s->notify_fds[1] = -1;
+        raise_nng_error(rv);
+    }
+    rv = nng_pipe_notify(s->socket, NNG_PIPE_EV_REM_POST, pipe_notify_cb, s);
+    if (rv != 0) {
+        close(s->notify_fds[0]);
+        close(s->notify_fds[1]);
+        s->notify_fds[0] = -1;
+        s->notify_fds[1] = -1;
+        raise_nng_error(rv);
+    }
+
+    return INT2NUM(s->notify_fds[0]);
+}
+
+static VALUE
+socket_pipe_notify_fd(VALUE self)
+{
+    rbnng_socket_t *s = socket_get(self);
+    if (s->notify_fds[0] < 0)
+        rb_raise(rb_eRuntimeError, "pipe_notify_start has not been called");
+    return INT2NUM(s->notify_fds[0]);
+}
+
+static VALUE
+socket_recv_pipe_event(VALUE self)
+{
+    rbnng_socket_t *s = socket_get(self);
+    if (s->notify_fds[0] < 0)
+        rb_raise(rb_eRuntimeError, "pipe_notify_start has not been called");
+
+    uint8_t buf[PIPE_EVENT_SIZE];
+    ssize_t n = read(s->notify_fds[0], buf, PIPE_EVENT_SIZE);
+    if (n < (ssize_t)PIPE_EVENT_SIZE)
+        return Qnil;
+
+    VALUE sym = (buf[0] == 1) ? ID2SYM(rb_intern("connect"))
+                              : ID2SYM(rb_intern("disconnect"));
+
+    nng_pipe p;
+    memcpy(&p, buf + 1, sizeof(nng_pipe));
+
+    return rb_ary_new3(2, sym, rbnng_pipe_wrap(p));
+}
+
+/* Bus0: set default recv timeout so broadcast doesn't block forever */
+static VALUE
+bus0_init(int argc, VALUE *argv, VALUE self)
+{
+    bus0_init_inner(argc, argv, self);
+    rbnng_socket_t *s = socket_get(self);
+    nng_duration cur;
+    int rv = nng_socket_get_ms(s->socket, NNG_OPT_RECVTIMEO, &cur);
+    if (rv == 0 && cur < 0) {
+        /* no timeout was set via kwarg, apply default */
+        rv = nng_socket_set_ms(s->socket, NNG_OPT_RECVTIMEO, 100);
+        if (rv != 0)
+            raise_nng_error(rv);
+    }
+    return self;
+}
+
+/* ── Ruby class registration ───────────────────────────────────── */
+
+#define REG_PROTO(mod, name, init_fn)                                 \
+    do {                                                              \
+        VALUE cls = rb_define_class_under(mod, name, base);           \
+        rb_define_method(cls, "initialize", init_fn, -1);             \
+    } while (0)
+
+void
+rbnng_socket_init(VALUE nng_module)
+{
+    VALUE mod = rb_define_module_under(nng_module, "Socket");
+
+    VALUE base = rb_define_class_under(mod, "Base", rb_cObject);
+    rb_define_alloc_func(base, socket_alloc);
+
+    rb_define_method(base, "close",          socket_close,          0);
+    rb_define_method(base, "listen",         socket_listen,         1);
+    rb_define_method(base, "dial",           socket_dial,           1);
+    rb_define_method(base, "receive",        socket_receive,        0);
+    rb_define_method(base, "send",           socket_send,           1);
+    rb_define_method(base, "forward",        socket_forward,        1);
+    rb_define_method(base, "recv_fd",        socket_recv_fd,        0);
+    rb_define_method(base, "send_fd",        socket_send_fd,        0);
+    rb_define_method(base, "_listen_tls",    socket_listen_tls,     6);
+    rb_define_method(base, "_dial_tls",      socket_dial_tls,       6);
+    rb_define_method(base, "get_opt_int",    socket_get_opt_int,    1);
+    rb_define_method(base, "set_opt_int",    socket_set_opt_int,    2);
+    rb_define_method(base, "get_opt_ms",     socket_get_opt_ms,     1);
+    rb_define_method(base, "set_opt_ms",     socket_set_opt_ms,     2);
+    rb_define_method(base, "get_opt_size",   socket_get_opt_size,   1);
+    rb_define_method(base, "set_opt_size",   socket_set_opt_size,   2);
+    rb_define_method(base, "get_opt_string", socket_get_opt_string, 1);
+    rb_define_method(base, "set_opt_string", socket_set_opt_string, 2);
+    rb_define_method(base, "pipe_notify_start",  socket_pipe_notify_start,  0);
+    rb_define_method(base, "pipe_notify_fd",     socket_pipe_notify_fd,     0);
+    rb_define_method(base, "recv_pipe_event",    socket_recv_pipe_event,    0);
 
-  int rv;
-  if ((rv = nng_listen(p_rbnngSocket->socket, StringValueCStr(url), NULL, 0)) !=
-      0) {
-    raise_error(rv);
-  }
+    REG_PROTO(mod, "Pair0",       pair0_init);
+    REG_PROTO(mod, "Pair1",       pair1_init);
+    REG_PROTO(mod, "Bus0",        bus0_init);
+    REG_PROTO(mod, "Pub0",        pub0_init);
+    VALUE cSub0 = rb_define_class_under(mod, "Sub0", base);
+    rb_define_method(cSub0, "initialize", sub0_init, -1);
+    rb_define_method(cSub0, "subscribe", sub0_subscribe, 1);
+    rb_define_method(cSub0, "unsubscribe", sub0_unsubscribe, 1);
+    REG_PROTO(mod, "Push0",       push0_init);
+    REG_PROTO(mod, "Pull0",       pull0_init);
+    REG_PROTO(mod, "Req0",        req0_init);
+    REG_PROTO(mod, "Rep0",        rep0_init);
+    REG_PROTO(mod, "Surveyor0",   surveyor0_init);
+    REG_PROTO(mod, "Respondent0", respondent0_init);
 }