nng 0.1.0 → 1.0.1

data/ext/rbnng/exceptions.c

@@ -1,217 +1,126 @@
-/*
- * Copyright (c) 2021 Adib Saad
- *
- */
-#include <nng/nng.h>
-#include <ruby.h>
+#include "rbnng.h"
 
-VALUE rbnng_eBase = Qnil;
-
-VALUE rbnng_eInterrupted = Qnil;
-VALUE rbnng_eOutOfMemory = Qnil;
-VALUE rbnng_eInvalidArgument = Qnil;
-VALUE rbnng_eResourceBusy = Qnil;
-VALUE rbnng_eTimedOut = Qnil;
-VALUE rbnng_eConnectionRefused = Qnil;
-VALUE rbnng_eObjectClosed = Qnil;
-VALUE rbnng_eTryAgain = Qnil;
-VALUE rbnng_eNotSupported = Qnil;
-VALUE rbnng_eAddressInUse = Qnil;
-VALUE rbnng_eIncorrectState = Qnil;
-VALUE rbnng_eEntryNotFound = Qnil;
-VALUE rbnng_eProtocolError = Qnil;
-VALUE rbnng_eDestinationUnreachable = Qnil;
-VALUE rbnng_eAddressInvalid = Qnil;
-VALUE rbnng_ePermissionDenied = Qnil;
-VALUE rbnng_eMessageTooLarge = Qnil;
-VALUE rbnng_eConnectionReset = Qnil;
-VALUE rbnng_eConnectionAborted = Qnil;
-VALUE rbnng_eOperationCanceled = Qnil;
-VALUE rbnng_eOutOfFiles = Qnil;
-VALUE rbnng_eOutOfSpace = Qnil;
-VALUE rbnng_eResourceAlreadyExists = Qnil;
-VALUE rbnng_eReadOnlyResource = Qnil;
-VALUE rbnng_eWriteOnlyResource = Qnil;
-VALUE rbnng_eCryptographicError = Qnil;
-VALUE rbnng_ePeerCouldNotBeAuthenticated = Qnil;
-VALUE rbnng_eOptionRequiresArgument = Qnil;
-VALUE rbnng_eAmbiguousOption = Qnil;
-VALUE rbnng_eIncorrectType = Qnil;
-VALUE rbnng_eConnectionShutdown = Qnil;
-VALUE rbnng_eInternalErrorDetected = Qnil;
+static VALUE eBase;
+static VALUE eInterrupted;
+static VALUE eOutOfMemory;
+static VALUE eInvalidArgument;
+static VALUE eResourceBusy;
+static VALUE eTimedOut;
+static VALUE eConnectionRefused;
+static VALUE eObjectClosed;
+static VALUE eTryAgain;
+static VALUE eNotSupported;
+static VALUE eAddressInUse;
+static VALUE eIncorrectState;
+static VALUE eEntryNotFound;
+static VALUE eProtocolError;
+static VALUE eDestinationUnreachable;
+static VALUE eAddressInvalid;
+static VALUE ePermissionDenied;
+static VALUE eMessageTooLarge;
+static VALUE eConnectionAborted;
+static VALUE eConnectionReset;
+static VALUE eOperationCanceled;
+static VALUE eOutOfFiles;
+static VALUE eOutOfSpace;
+static VALUE eResourceAlreadyExists;
+static VALUE eReadOnlyResource;
+static VALUE eWriteOnlyResource;
+static VALUE eCryptographicError;
+static VALUE ePeerCouldNotBeAuthenticated;
+static VALUE eOptionRequiresArgument;
+static VALUE eAmbiguousOption;
+static VALUE eIncorrectType;
+static VALUE eConnectionShutdown;
+static VALUE eInternalErrorDetected;
 
 void
-rbnng_exceptions_Init(VALUE nng_module)
+raise_nng_error(int rv)
 {
-  VALUE errorModule = rb_define_module_under(nng_module, "Error");
-  rbnng_eBase = rb_define_class_under(errorModule, "Error", rb_eRuntimeError);
+    const char *msg = nng_strerror(rv);
+    VALUE cls;
+
+    switch (rv) {
+    case NNG_EINTR:        cls = eInterrupted; break;
+    case NNG_ENOMEM:       cls = eOutOfMemory; break;
+    case NNG_EINVAL:       cls = eInvalidArgument; break;
+    case NNG_EBUSY:        cls = eResourceBusy; break;
+    case NNG_ETIMEDOUT:    cls = eTimedOut; break;
+    case NNG_ECONNREFUSED: cls = eConnectionRefused; break;
+    case NNG_ECLOSED:      cls = eObjectClosed; break;
+    case NNG_EAGAIN:       cls = eTryAgain; break;
+    case NNG_ENOTSUP:      cls = eNotSupported; break;
+    case NNG_EADDRINUSE:   cls = eAddressInUse; break;
+    case NNG_ESTATE:       cls = eIncorrectState; break;
+    case NNG_ENOENT:       cls = eEntryNotFound; break;
+    case NNG_EPROTO:       cls = eProtocolError; break;
+    case NNG_EUNREACHABLE: cls = eDestinationUnreachable; break;
+    case NNG_EADDRINVAL:   cls = eAddressInvalid; break;
+    case NNG_EPERM:        cls = ePermissionDenied; break;
+    case NNG_EMSGSIZE:     cls = eMessageTooLarge; break;
+    case NNG_ECONNABORTED: cls = eConnectionAborted; break;
+    case NNG_ECONNRESET:   cls = eConnectionReset; break;
+    case NNG_ECANCELED:    cls = eOperationCanceled; break;
+    case NNG_ENOFILES:     cls = eOutOfFiles; break;
+    case NNG_ENOSPC:       cls = eOutOfSpace; break;
+    case NNG_EEXIST:       cls = eResourceAlreadyExists; break;
+    case NNG_EREADONLY:    cls = eReadOnlyResource; break;
+    case NNG_EWRITEONLY:   cls = eWriteOnlyResource; break;
+    case NNG_ECRYPTO:      cls = eCryptographicError; break;
+    case NNG_EPEERAUTH:    cls = ePeerCouldNotBeAuthenticated; break;
+    case NNG_ENOARG:       cls = eOptionRequiresArgument; break;
+    case NNG_EAMBIGUOUS:   cls = eAmbiguousOption; break;
+    case NNG_EBADTYPE:     cls = eIncorrectType; break;
+    case NNG_ECONNSHUT:    cls = eConnectionShutdown; break;
+    case NNG_EINTERNAL:    cls = eInternalErrorDetected; break;
+    default:               cls = eBase; break;
+    }
 
-  rbnng_eInterrupted =
-    rb_define_class_under(errorModule, "Interrupted", rbnng_eBase);
-  rbnng_eOutOfMemory =
-    rb_define_class_under(errorModule, "OutOfMemory", rbnng_eBase);
-  rbnng_eInvalidArgument =
-    rb_define_class_under(errorModule, "InvalidArgument", rbnng_eBase);
-  rbnng_eResourceBusy =
-    rb_define_class_under(errorModule, "ResourceBusy", rbnng_eBase);
-  rbnng_eTimedOut = rb_define_class_under(errorModule, "TimedOut", rbnng_eBase);
-  rbnng_eConnectionRefused =
-    rb_define_class_under(errorModule, "ConnectionRefused", rbnng_eBase);
-  rbnng_eObjectClosed =
-    rb_define_class_under(errorModule, "ObjectClosed", rbnng_eBase);
-  rbnng_eTryAgain = rb_define_class_under(errorModule, "TryAgain", rbnng_eBase);
-  rbnng_eNotSupported =
-    rb_define_class_under(errorModule, "NotSupported", rbnng_eBase);
-  rbnng_eAddressInUse =
-    rb_define_class_under(errorModule, "AddressInUse", rbnng_eBase);
-  rbnng_eIncorrectState =
-    rb_define_class_under(errorModule, "IncorrectState", rbnng_eBase);
-  rbnng_eEntryNotFound =
-    rb_define_class_under(errorModule, "EntryNotFound", rbnng_eBase);
-  rbnng_eProtocolError =
-    rb_define_class_under(errorModule, "ProtocolError", rbnng_eBase);
-  rbnng_eDestinationUnreachable =
-    rb_define_class_under(errorModule, "DestinationUnreachable", rbnng_eBase);
-  rbnng_eAddressInvalid =
-    rb_define_class_under(errorModule, "AddressInvalid", rbnng_eBase);
-  rbnng_ePermissionDenied =
-    rb_define_class_under(errorModule, "PermissionDenied", rbnng_eBase);
-  rbnng_eMessageTooLarge =
-    rb_define_class_under(errorModule, "MessageTooLarge", rbnng_eBase);
-  rbnng_eConnectionReset =
-    rb_define_class_under(errorModule, "ConnectionReset", rbnng_eBase);
-  rbnng_eConnectionAborted =
-    rb_define_class_under(errorModule, "ConnectionAborted", rbnng_eBase);
-  rbnng_eOperationCanceled =
-    rb_define_class_under(errorModule, "OperationCanceled", rbnng_eBase);
-  rbnng_eOutOfFiles =
-    rb_define_class_under(errorModule, "OutOfFiles", rbnng_eBase);
-  rbnng_eOutOfSpace =
-    rb_define_class_under(errorModule, "OutOfSpace", rbnng_eBase);
-  rbnng_eResourceAlreadyExists =
-    rb_define_class_under(errorModule, "ResourceAlreadyExists", rbnng_eBase);
-  rbnng_eReadOnlyResource =
-    rb_define_class_under(errorModule, "ReadOnlyResource", rbnng_eBase);
-  rbnng_eWriteOnlyResource =
-    rb_define_class_under(errorModule, "WriteOnlyResource", rbnng_eBase);
-  rbnng_eCryptographicError =
-    rb_define_class_under(errorModule, "CryptographicError", rbnng_eBase);
-  rbnng_ePeerCouldNotBeAuthenticated = rb_define_class_under(
-    errorModule, "PeerCouldNotBeAuthenticated", rbnng_eBase);
-  rbnng_eOptionRequiresArgument =
-    rb_define_class_under(errorModule, "OptionRequiresArgument", rbnng_eBase);
-  rbnng_eAmbiguousOption =
-    rb_define_class_under(errorModule, "AmbiguousOption", rbnng_eBase);
-  rbnng_eIncorrectType =
-    rb_define_class_under(errorModule, "IncorrectType", rbnng_eBase);
-  rbnng_eConnectionShutdown =
-    rb_define_class_under(errorModule, "ConnectionShutdown", rbnng_eBase);
-  rbnng_eInternalErrorDetected =
-    rb_define_class_under(errorModule, "InternalErrorDetected", rbnng_eBase);
+    rb_raise(cls, "%s", msg);
 }
 
+#define DEF_ERR(var, mod, name) \
+    var = rb_define_class_under(mod, name, eBase); \
+    rb_gc_register_mark_object(var)
+
 void
-raise_error(int nng_errno)
+rbnng_exceptions_init(VALUE nng_module)
 {
-  switch (nng_errno) {
-    case NNG_EINTR:
-      rb_raise(rbnng_eInterrupted, "");
-      break;
-    case NNG_ENOMEM:
-      rb_raise(rbnng_eOutOfMemory, "");
-      break;
-    case NNG_EINVAL:
-      rb_raise(rbnng_eInvalidArgument, "");
-      break;
-    case NNG_EBUSY:
-      rb_raise(rbnng_eResourceBusy, "");
-      break;
-    case NNG_ETIMEDOUT:
-      rb_raise(rbnng_eTimedOut, "");
-      break;
-    case NNG_ECONNREFUSED:
-      rb_raise(rbnng_eConnectionRefused, "");
-      break;
-    case NNG_ECLOSED:
-      rb_raise(rbnng_eObjectClosed, "");
-      break;
-    case NNG_EAGAIN:
-      rb_raise(rbnng_eTryAgain, "");
-      break;
-    case NNG_ENOTSUP:
-      rb_raise(rbnng_eNotSupported, "");
-      break;
-    case NNG_EADDRINUSE:
-      rb_raise(rbnng_eAddressInUse, "");
-      break;
-    case NNG_ESTATE:
-      rb_raise(rbnng_eIncorrectState, "");
-      break;
-    case NNG_ENOENT:
-      rb_raise(rbnng_eEntryNotFound, "");
-      break;
-    case NNG_EPROTO:
-      rb_raise(rbnng_eProtocolError, "");
-      break;
-    case NNG_EUNREACHABLE:
-      rb_raise(rbnng_eDestinationUnreachable, "");
-      break;
-    case NNG_EADDRINVAL:
-      rb_raise(rbnng_eAddressInvalid, "");
-      break;
-    case NNG_EPERM:
-      rb_raise(rbnng_ePermissionDenied, "");
-      break;
-    case NNG_EMSGSIZE:
-      rb_raise(rbnng_eMessageTooLarge, "");
-      break;
-    case NNG_ECONNRESET:
-      rb_raise(rbnng_eConnectionReset, "");
-      break;
-    case NNG_ECONNABORTED:
-      rb_raise(rbnng_eConnectionAborted, "");
-      break;
-    case NNG_ECANCELED:
-      rb_raise(rbnng_eOperationCanceled, "");
-      break;
-    case NNG_ENOFILES:
-      rb_raise(rbnng_eOutOfFiles, "");
-      break;
-    case NNG_ENOSPC:
-      rb_raise(rbnng_eOutOfSpace, "");
-      break;
-    case NNG_EEXIST:
-      rb_raise(rbnng_eResourceAlreadyExists, "");
-      break;
-    case NNG_EREADONLY:
-      rb_raise(rbnng_eReadOnlyResource, "");
-      break;
-    case NNG_EWRITEONLY:
-      rb_raise(rbnng_eWriteOnlyResource, "");
-      break;
-    case NNG_ECRYPTO:
-      rb_raise(rbnng_eCryptographicError, "");
-      break;
-    case NNG_EPEERAUTH:
-      rb_raise(rbnng_ePeerCouldNotBeAuthenticated, "");
-      break;
-    case NNG_ENOARG:
-      rb_raise(rbnng_eOptionRequiresArgument, "");
-      break;
-    case NNG_EAMBIGUOUS:
-      rb_raise(rbnng_eAmbiguousOption, "");
-      break;
-    case NNG_EBADTYPE:
-      rb_raise(rbnng_eIncorrectType, "");
-      break;
-    case NNG_ECONNSHUT:
-      rb_raise(rbnng_eConnectionShutdown, "");
-      break;
-    case NNG_EINTERNAL:
-      rb_raise(rbnng_eInternalErrorDetected, "");
-      break;
-    default:
-      rb_raise(rbnng_eBase, "errno %d, %s", nng_errno, nng_strerror(nng_errno));
-      break;
-  }
+    eBase = rb_define_class_under(nng_module, "Error", rb_eRuntimeError);
+    rb_gc_register_mark_object(eBase);
+
+    VALUE m = eBase;
+
+    DEF_ERR(eInterrupted,                m, "Interrupted");
+    DEF_ERR(eOutOfMemory,                m, "OutOfMemory");
+    DEF_ERR(eInvalidArgument,            m, "InvalidArgument");
+    DEF_ERR(eResourceBusy,               m, "ResourceBusy");
+    DEF_ERR(eTimedOut,                   m, "TimedOut");
+    DEF_ERR(eConnectionRefused,          m, "ConnectionRefused");
+    DEF_ERR(eObjectClosed,               m, "ObjectClosed");
+    DEF_ERR(eTryAgain,                   m, "TryAgain");
+    DEF_ERR(eNotSupported,               m, "NotSupported");
+    DEF_ERR(eAddressInUse,               m, "AddressInUse");
+    DEF_ERR(eIncorrectState,             m, "IncorrectState");
+    DEF_ERR(eEntryNotFound,              m, "EntryNotFound");
+    DEF_ERR(eProtocolError,              m, "ProtocolError");
+    DEF_ERR(eDestinationUnreachable,     m, "DestinationUnreachable");
+    DEF_ERR(eAddressInvalid,             m, "AddressInvalid");
+    DEF_ERR(ePermissionDenied,           m, "PermissionDenied");
+    DEF_ERR(eMessageTooLarge,            m, "MessageTooLarge");
+    DEF_ERR(eConnectionAborted,          m, "ConnectionAborted");
+    DEF_ERR(eConnectionReset,            m, "ConnectionReset");
+    DEF_ERR(eOperationCanceled,          m, "OperationCanceled");
+    DEF_ERR(eOutOfFiles,                 m, "OutOfFiles");
+    DEF_ERR(eOutOfSpace,                 m, "OutOfSpace");
+    DEF_ERR(eResourceAlreadyExists,      m, "ResourceAlreadyExists");
+    DEF_ERR(eReadOnlyResource,           m, "ReadOnlyResource");
+    DEF_ERR(eWriteOnlyResource,          m, "WriteOnlyResource");
+    DEF_ERR(eCryptographicError,         m, "CryptographicError");
+    DEF_ERR(ePeerCouldNotBeAuthenticated,m, "PeerCouldNotBeAuthenticated");
+    DEF_ERR(eOptionRequiresArgument,     m, "OptionRequiresArgument");
+    DEF_ERR(eAmbiguousOption,            m, "AmbiguousOption");
+    DEF_ERR(eIncorrectType,              m, "IncorrectType");
+    DEF_ERR(eConnectionShutdown,         m, "ConnectionShutdown");
+    DEF_ERR(eInternalErrorDetected,      m, "InternalErrorDetected");
 }

data/ext/rbnng/extconf.rb

@@ -1,21 +1,8 @@
-#
-#    Copyright (c) 2021 Adib Saad
-#
-require 'mkmf'
-dir_config('nng')
+require "mkmf"
 
-def header?
-  have_header('nng/nng.h') ||
-    find_header('nng/nng.h', '/opt/local/include', '/usr/local/include', '/usr/include')
-end
+pkg_config("libnng") || dir_config("nng")
+have_library("nng", "nng_version") || abort("libnng not found")
+have_header("nng/nng.h") || abort("nng/nng.h not found")
+have_header("nng/supplemental/tls/tls.h")
 
-def library?
-  have_library('nng', 'nng_fini') ||
-    find_library('nng', 'nng_fini', '/opt/local/lib', '/usr/local/lib', '/usr/lib')
-end
-
-if header? && library?
-  create_makefile("nng/rbnng")
-else
-  raise "Couldn't find nng library. try setting --with-nng-dir=<path> to tell me where it is."
-end
+create_makefile("nng/rbnng")

data/ext/rbnng/message.c

@@ -0,0 +1,183 @@
+#include "rbnng.h"
+
+#define HEADER_ELEMENT_SIZE 4
+
+VALUE cMessage = Qnil;
+
+/* ── TypedData ──────────────────────────────────────────────────── */
+
+static void
+msg_free(void *ptr)
+{
+    rbnng_msg_t *m = ptr;
+    if (m->msg)
+        nng_msg_free(m->msg);
+    xfree(m);
+}
+
+static size_t
+msg_memsize(const void *ptr)
+{
+    return sizeof(rbnng_msg_t);
+}
+
+const rb_data_type_t rbnng_msg_type = {
+    .wrap_struct_name = "NNG::Message",
+    .function = {
+        .dmark  = NULL,
+        .dfree  = msg_free,
+        .dsize  = msg_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+msg_alloc(VALUE klass)
+{
+    rbnng_msg_t *m;
+    return TypedData_Make_Struct(klass, rbnng_msg_t, &rbnng_msg_type, m);
+}
+
+VALUE
+rbnng_msg_wrap(nng_msg *msg)
+{
+    VALUE obj = msg_alloc(cMessage);
+    rbnng_msg_t *m;
+    TypedData_Get_Struct(obj, rbnng_msg_t, &rbnng_msg_type, m);
+    m->msg = msg;
+    return obj;
+}
+
+static inline rbnng_msg_t *
+msg_get(VALUE self)
+{
+    rbnng_msg_t *m;
+    TypedData_Get_Struct(self, rbnng_msg_t, &rbnng_msg_type, m);
+    return m;
+}
+
+static inline nng_msg *
+msg_ptr(VALUE self)
+{
+    rbnng_msg_t *m = msg_get(self);
+    if (!m->msg)
+        rb_raise(rb_eRuntimeError, "message already consumed");
+    return m->msg;
+}
+
+/* ── Methods ────────────────────────────────────────────────────── */
+
+static VALUE
+msg_body(VALUE self)
+{
+    nng_msg *p = msg_ptr(self);
+    return rb_str_new(nng_msg_body(p), nng_msg_len(p));
+}
+
+static VALUE
+msg_body_clear(VALUE self)
+{
+    nng_msg_clear(msg_ptr(self));
+    return Qnil;
+}
+
+static VALUE
+msg_body_append(VALUE self, VALUE data)
+{
+    nng_msg *p = msg_ptr(self);
+    int rv = nng_msg_append(p, RSTRING_PTR(data), RSTRING_LEN(data));
+    if (rv != 0)
+        raise_nng_error(rv);
+    return Qnil;
+}
+
+static VALUE
+msg_header(VALUE self)
+{
+    nng_msg *p = msg_ptr(self);
+    const char *data = nng_msg_header(p);
+    size_t len = nng_msg_header_len(p);
+    size_t count = len / HEADER_ELEMENT_SIZE;
+
+    VALUE ary = rb_ary_new_capa((long)count);
+    for (size_t i = 0; i < count; i++)
+        rb_ary_push(ary, rb_str_new(data + i * HEADER_ELEMENT_SIZE,
+                                    HEADER_ELEMENT_SIZE));
+    return ary;
+}
+
+static VALUE
+msg_set_header(VALUE self, VALUE elements)
+{
+    nng_msg *p = msg_ptr(self);
+    Check_Type(elements, T_ARRAY);
+
+    long count = RARRAY_LEN(elements);
+
+    /* Validate all elements first */
+    for (long i = 0; i < count; i++) {
+        VALUE el = rb_ary_entry(elements, i);
+        StringValue(el);
+        if (RSTRING_LEN(el) != HEADER_ELEMENT_SIZE)
+            rb_raise(rb_eArgError,
+                     "header element must be exactly %d bytes, got %ld",
+                     HEADER_ELEMENT_SIZE, RSTRING_LEN(el));
+    }
+
+    /* Clear and write */
+    nng_msg_header_clear(p);
+    for (long i = 0; i < count; i++) {
+        VALUE el = rb_ary_entry(elements, i);
+        int rv = nng_msg_header_append(p, RSTRING_PTR(el), RSTRING_LEN(el));
+        if (rv != 0)
+            raise_nng_error(rv);
+    }
+
+    return elements;
+}
+
+static VALUE
+msg_dup(VALUE self)
+{
+    nng_msg *p = msg_ptr(self);
+    nng_msg *copy;
+    int rv = nng_msg_dup(&copy, p);
+    if (rv != 0)
+        raise_nng_error(rv);
+    return rbnng_msg_wrap(copy);
+}
+
+static VALUE
+msg_consumed_p(VALUE self)
+{
+    rbnng_msg_t *m = msg_get(self);
+    return m->msg ? Qfalse : Qtrue;
+}
+
+static VALUE
+msg_pipe(VALUE self)
+{
+    nng_pipe p = nng_msg_get_pipe(msg_ptr(self));
+    if (nng_pipe_id(p) < 0)
+        return Qnil;
+    return rbnng_pipe_wrap(p);
+}
+
+/* ── Init ───────────────────────────────────────────────────────── */
+
+void
+rbnng_msg_init(VALUE nng_module)
+{
+    cMessage = rb_define_class_under(nng_module, "Message", rb_cObject);
+    rb_define_alloc_func(cMessage, msg_alloc);
+
+    rb_define_method(cMessage, "body",        msg_body,        0);
+    rb_define_method(cMessage, "to_s",        msg_body,        0);
+    rb_define_method(cMessage, "body_clear",  msg_body_clear,  0);
+    rb_define_method(cMessage, "body_append", msg_body_append, 1);
+    rb_define_method(cMessage, "header",      msg_header,      0);
+    rb_define_method(cMessage, "header=",     msg_set_header,  1);
+    rb_define_method(cMessage, "dup",         msg_dup,         0);
+    rb_define_method(cMessage, "consumed?",   msg_consumed_p,  0);
+    rb_define_method(cMessage, "pipe",        msg_pipe,        0);
+}

data/ext/rbnng/pipe.c

@@ -0,0 +1,81 @@
+#include "rbnng.h"
+
+VALUE cPipe = Qnil;
+
+/* ── TypedData ──────────────────────────────────────────────────── */
+
+static size_t
+pipe_memsize(const void *ptr)
+{
+    return sizeof(rbnng_pipe_t);
+}
+
+const rb_data_type_t rbnng_pipe_type = {
+    .wrap_struct_name = "NNG::Pipe",
+    .function = {
+        .dmark  = NULL,
+        .dfree  = RUBY_DEFAULT_FREE,
+        .dsize  = pipe_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE
+rbnng_pipe_wrap(nng_pipe pipe)
+{
+    rbnng_pipe_t *p;
+    VALUE obj = TypedData_Make_Struct(cPipe, rbnng_pipe_t, &rbnng_pipe_type, p);
+    p->pipe = pipe;
+    return obj;
+}
+
+static inline nng_pipe
+pipe_get(VALUE self)
+{
+    rbnng_pipe_t *p;
+    TypedData_Get_Struct(self, rbnng_pipe_t, &rbnng_pipe_type, p);
+    return p->pipe;
+}
+
+/* ── Methods ────────────────────────────────────────────────────── */
+
+static VALUE
+pipe_id(VALUE self)
+{
+    return INT2NUM(nng_pipe_id(pipe_get(self)));
+}
+
+static VALUE
+pipe_tls_verified_p(VALUE self)
+{
+    bool val;
+    int rv = nng_pipe_get_bool(pipe_get(self), NNG_OPT_TLS_VERIFIED, &val);
+    if (rv != 0)
+        return Qfalse;
+    return val ? Qtrue : Qfalse;
+}
+
+static VALUE
+pipe_tls_peer_cn(VALUE self)
+{
+    char *val;
+    int rv = nng_pipe_get_string(pipe_get(self), NNG_OPT_TLS_PEER_CN, &val);
+    if (rv != 0)
+        return Qnil;
+    VALUE str = rb_str_new_cstr(val);
+    nng_strfree(val);
+    return str;
+}
+
+/* ── Init ───────────────────────────────────────────────────────── */
+
+void
+rbnng_pipe_init(VALUE nng_module)
+{
+    cPipe = rb_define_class_under(nng_module, "Pipe", rb_cObject);
+    rb_undef_alloc_func(cPipe);
+
+    rb_define_method(cPipe, "id",            pipe_id,             0);
+    rb_define_method(cPipe, "tls_verified?", pipe_tls_verified_p, 0);
+    rb_define_method(cPipe, "tls_peer_cn",   pipe_tls_peer_cn,    0);
+}

data/ext/rbnng/rbnng.c

@@ -1,38 +1,24 @@
-/*
- * Copyright (c) 2021 Adib Saad
- *
- */
-#include <nng/nng.h>
-#include <ruby.h>
-
-#include "msg.h"
 #include "rbnng.h"
-#include "socket.h"
 
 static VALUE
-library_version(VALUE self_)
+library_version(VALUE self)
 {
-  return rb_ary_new3(3,
-                     INT2NUM(NNG_MAJOR_VERSION),
-                     INT2NUM(NNG_MINOR_VERSION),
-                     INT2NUM(NNG_PATCH_VERSION));
+    return rb_ary_new3(3,
+                       INT2NUM(NNG_MAJOR_VERSION),
+                       INT2NUM(NNG_MINOR_VERSION),
+                       INT2NUM(NNG_PATCH_VERSION));
 }
 
 void
-Init_rbnng()
+Init_rbnng(void)
 {
-  VALUE nng_module = rb_define_module("NNG");
-  rb_define_singleton_method(nng_module, "nng_version", library_version, 0);
-  rbnng_exceptions_Init(nng_module);
-  rbnng_msg_Init(nng_module);
-  rbnng_rep0_Init(nng_module);
-  rbnng_req0_Init(nng_module);
-  rbnng_pub0_Init(nng_module);
-  rbnng_sub0_Init(nng_module);
-  rbnng_pair_Init(nng_module);
-  rbnng_bus0_Init(nng_module);
-  rbnng_surveyor0_Init(nng_module);
-  rbnng_respondent0_Init(nng_module);
-  rbnng_push0_Init(nng_module);
-  rbnng_pull0_Init(nng_module);
+    VALUE nng = rb_define_module("NNG");
+    rb_define_singleton_method(nng, "nng_version", library_version, 0);
+
+    rbnng_exceptions_init(nng);
+    rbnng_msg_init(nng);
+    rbnng_pipe_init(nng);
+    rbnng_socket_init(nng);
+    rbnng_stats_init(nng);
+    rbnng_device_init(nng);
 }