sctp-socket 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f9f0ecd09038bfc074d38f36b387c26a5f203c3d57ae5d6ad7f5b2c085e945f
-  data.tar.gz: 563a9e79224c46e71872de30a59a17ece441113dcab2cc8d4e153a7a89313b97
+  metadata.gz: 020ddee983f419ae152f2380b8275e61f66e70721f253eb33b65968a2bd82ef6
+  data.tar.gz: 7b9aa313541d38d4e1656813f00c2efcc4d5d61d1dcd1888706757e8e6c3ca8f
 SHA512:
-  metadata.gz: 714abd0b5f6ecb95778ddf81d03dbfc6d23f1bfcfdebe62d4bed25cf3aaecc869e1235f6e5c04a5de123b0022ed9b6bdcb39d13a340d0aae3f3e50340c10ad26
-  data.tar.gz: c88bcdc5f0f456e4ef3a75f9c06f52ba60600959bfe7d654d398dfe0a3c8f9a19d76ee4d577c119a0b367c525b6395172a86ff6e6259fff8e697b345e122f616
+  metadata.gz: 8db4f1600b5afe84c5930eb2e3953a1eb71353ba53f6fbf6637661cd8266ac7bf208528e7809f55110ae16ef3bb09412fca6bc5ce317c161ecaed9c11697fc74
+  data.tar.gz: 46d38b4f47252e7df76557215d430a21b94009270ab6e9e09e0d08e8bc34d990ded3e059a4bd5b661d52c01bcc7a5743242a6e9d3ec5cbbdf3b29ff56e9ff350

data/.gitignore

@@ -5,3 +5,4 @@
 Makefile
 tmp/
 .vscode
+*.bundle

data/CHANGES.md

@@ -1,3 +1,7 @@
+## 0.3.0 - 8-Feb-2026
+* Add a compatability layer for libusrsctp. This was mainly for MacOS, but
+  it should work on any platform.
+
 ## 0.2.2 - 7-Jan-2026
 * Added IPv6 support.
 * Some internal refactoring and updates, potential memory leak fixes, etc.

data/MANIFEST.md

@@ -1,12 +1,49 @@
 * CHANGES.md
 * certs/djberg96_pub.pem
 * examples/client_example.rb
+* examples/client_for_server_test.rb
+* examples/sctp_server_example.rb
 * examples/server_example.rb
+* examples/server_using_sctp_server.rb
+* ext/sctp/extconf.rb
+* ext/sctp/sctp_compat.h
 * ext/sctp/socket.c
-* ext/sctp/socket.h
 * Gemfile
+* lib/sctp/server.rb
 * LICENSE
+* MANIFEST.md
 * Rakefile
 * README.md
 * sctp-socket.gemspec
-* spec/sctp_spec.rb
+* spec/active_shared_key_spec.rb
+* spec/auth_support_spec.rb
+* spec/autoclose_spec.rb
+* spec/bindx_spec.rb
+* spec/close_spec.rb
+* spec/connectx_spec.rb
+* spec/constants_spec.rb
+* spec/constructor_spec.rb
+* spec/get_default_send_params_spec.rb
+* spec/get_init_msg_spec.rb
+* spec/get_peer_address_params_spec.rb
+* spec/get_status_spec.rb
+* spec/getlocalnames_spec.rb
+* spec/getpeernames_spec.rb
+* spec/listen_spec.rb
+* spec/map_ipv4_spec.rb
+* spec/nodelay_spec.rb
+* spec/notification_spec.rb
+* spec/recvmsg_spec.rb
+* spec/recvv_spec.rb
+* spec/retransmission_info_spec.rb
+* spec/sctp_server_spec.rb
+* spec/sendmsg_spec.rb
+* spec/sendv_spec.rb
+* spec/set_default_send_params_spec.rb
+* spec/set_peer_address_params_spec.rb
+* spec/shared_key_spec.rb
+* spec/shared_spec_helper.rb
+* spec/shutdown_spec.rb
+* spec/spec_helper.rb
+* spec/subscribe_spec.rb
+* spec/version_spec.rb

data/Rakefile

@@ -48,11 +48,9 @@ task :create_dummy_links do
     system('sudo ip link set dummy2 up')
     system('ip link show')
   else
-    system("sudo ifconfig lo1 create")
-    system("sudo ifconfig lo1 1.1.1.1/24 up")
-    system("sudo ifconfig lo2 create")
-    system("sudo ifconfig lo2 1.1.1.2/24 up")
-    system("sudo ifconfig -a")
+    system("sudo ifconfig lo0 alias 1.1.1.1/24 up")
+    system("sudo ifconfig lo0 alias 1.1.1.2/24 up")
+    system("sudo ifconfig lo0")
   end
 end
 

data/ext/sctp/extconf.rb

@@ -2,36 +2,45 @@ require 'mkmf'
 
 dir_config('sctp')
 
-unless have_header('netinet/sctp.h')
-  os = IO.readlines('/etc/os-release').first.split('=').last
-  msg = "\nSCTP HEADERS NOT FOUND. PLEASE INSTALL THEM FIRST LIKE SO:\n\n"
-
-  if os =~ /red|fedora|centos/i
-    msg << "#####################################################################################\n"
-    msg << "# dnf install lksctp-tools                                                          #\n"
-    msg << "# dnf install kernel-modules-extra                                                  #\n"
-    msg << "#                                                                                   #\n"
-    msg << "# sed -e '/blacklist sctp/s/^b/#b/g' -i /etc/modprobe.d/sctp-blacklist.conf         #\n"
-    msg << "# sed -e '/blacklist sctp/s/^b/#b/g' -i /etc/modprobe.d/sctp_diag-blacklist.conf    #\n"
-    msg << "#                                                                                   #\n"
-    msg << "# sudo systemctl restart systemd-modules-load.service                               #\n"
-    msg << "#####################################################################################\n"
-  else
-    msg << "sudo apt-get install libsctp-dev lksctp-tools\n\n"
+if have_header('netinet/sctp.h')
+  # Native kernel SCTP (Linux, FreeBSD, etc.)
+  header = 'netinet/sctp.h'
+  have_library('sctp')
+  have_func('sctp_sendv', header)
+  have_func('sctp_recvv', header)
+else
+  # Fall back to usrsctp (primarily for macOS)
+  if RUBY_PLATFORM =~ /darwin/
+    homebrew_prefix = ENV['HOMEBREW_PREFIX'] || '/opt/homebrew'
+
+    if File.directory?("#{homebrew_prefix}/include")
+      $CFLAGS  << " -I#{homebrew_prefix}/include"
+      $LDFLAGS << " -L#{homebrew_prefix}/lib"
+    end
   end
 
-  warn msg
-  exit
-end
+  unless have_header('usrsctp.h')
+    abort <<~MSG
 
-header = 'netinet/sctp.h'
+      ERROR: Neither netinet/sctp.h nor usrsctp.h found.
 
-have_library('sctp')
+      On macOS:   brew install libusrsctp
+      On Ubuntu:  sudo apt-get install libsctp-dev lksctp-tools
+      On Fedora:  dnf install lksctp-tools kernel-modules-extra
 
-have_header('sys/param.h')
+    MSG
+  end
+
+  header = 'usrsctp.h'
+  have_library('usrsctp')
 
-have_func('sctp_sendv', header)
-have_func('sctp_recvv', header)
+  # usrsctp always provides sendv/recvv (as usrsctp_sendv/usrsctp_recvv),
+  # so define the feature macros so those code paths compile in.
+  $defs << '-DHAVE_SCTP_SENDV=1'
+  $defs << '-DHAVE_SCTP_RECVV=1'
+end
+
+have_header('sys/param.h')
 
 have_struct_member('struct sctp_event_subscribe', 'sctp_send_failure_event', header)
 have_struct_member('struct sctp_event_subscribe', 'sctp_stream_reset_event', header)

data/ext/sctp/sctp_compat.h

@@ -0,0 +1,369 @@
+/*
+ * sctp_compat.h - Compatibility layer for native kernel SCTP vs usrsctp.
+ *
+ * This header abstracts the API differences between the native Linux
+ * kernel SCTP stack (via netinet/sctp.h) and the userspace SCTP library
+ * (usrsctp) so the same C code can work with both backends.
+ *
+ * Key differences handled:
+ *   - Socket descriptor type: int (native) vs struct socket* (usrsctp)
+ *   - Ruby VALUE conversion: INT2NUM/NUM2INT vs LONG2NUM/NUM2LONG (64-bit safe)
+ *   - All sctp_* and POSIX socket calls mapped to sctp_sys_* wrappers
+ *   - Scatter/gather (iov) vs flat buffer (usrsctp_sendv/recvv)
+ *   - sctp_sendmsg/sctp_sendmsgx unified into sctp_sys_sendmsg
+ *   - sctp_recvmsg wrapped to use usrsctp_recvv
+ */
+#ifndef SCTP_COMPAT_H
+#define SCTP_COMPAT_H
+
+#ifdef HAVE_USRSCTP_H
+
+/* =========================================================================
+ * usrsctp backend (primarily for macOS)
+ * ========================================================================= */
+
+#include <usrsctp.h>
+
+/*
+ * usrsctp removed the deprecated sctp_sndrcvinfo struct; provide a compat
+ * definition so the rest of the code can use a single struct throughout.
+ * The sctp_sys_send / sctp_sys_recvmsg wrappers translate between this
+ * struct and the usrsctp-native sctp_sndinfo / sctp_rcvinfo.
+ */
+struct sctp_sndrcvinfo {
+  uint16_t       sinfo_stream;
+  uint16_t       sinfo_ssn;
+  uint16_t       sinfo_flags;
+  uint32_t       sinfo_ppid;
+  uint32_t       sinfo_context;
+  uint32_t       sinfo_timetolive;
+  uint32_t       sinfo_tsn;
+  uint32_t       sinfo_cumtsn;
+  sctp_assoc_t   sinfo_assoc_id;
+};
+
+/*
+ * usrsctp removed the deprecated SCTP_DEFAULT_SEND_PARAM sockopt (0x0b).
+ * We define a compat constant that our wrappers will translate into the
+ * appropriate SCTP_DEFAULT_SNDINFO call.  The value must not collide with
+ * any real usrsctp sockopt, so pick something far away.
+ */
+#define SCTP_DEFAULT_SEND_PARAM  0xF00D
+
+/*
+ * Socket descriptor type: struct socket* for usrsctp
+ */
+typedef struct socket* sctp_sock_t;
+
+/* Convert between Ruby VALUE and socket descriptor (64-bit pointer safe) */
+#define SCTP_FD_TO_NUM(fd)   LONG2NUM((intptr_t)(fd))
+#define NUM_TO_SCTP_FD(v)    ((sctp_sock_t)(uintptr_t)NUM2LONG(v))
+#define SCTP_FD_INVALID(fd)  ((fd) == NULL)
+
+/* --- Global usrsctp lifecycle --- */
+
+static int _usrsctp_initialized = 0;
+
+static inline void sctp_sys_global_init(void){
+  if(!_usrsctp_initialized){
+    usrsctp_init(0, NULL, NULL);
+    _usrsctp_initialized = 1;
+  }
+}
+
+/* --- Socket operations --- */
+
+static inline sctp_sock_t sctp_sys_socket(int domain, int type, int protocol){
+  sctp_sys_global_init();
+  return usrsctp_socket(domain, type, protocol, NULL, NULL, 0, NULL);
+}
+
+/* usrsctp_close returns void, wrap to return int for uniform error handling */
+static inline int sctp_sys_close(sctp_sock_t fd){
+  usrsctp_close(fd);
+  return 0;
+}
+
+#define sctp_sys_listen(fd, bl)   usrsctp_listen(fd, bl)
+#define sctp_sys_shutdown(fd, h)  usrsctp_shutdown(fd, h)
+
+/* --- Socket options --- */
+
+#define sctp_sys_setsockopt(fd, level, name, val, len) \
+    usrsctp_setsockopt(fd, level, name, val, len)
+#define sctp_sys_getsockopt(fd, level, name, val, len) \
+    usrsctp_getsockopt(fd, level, name, val, len)
+
+/* --- SCTP-specific operations (1:1 mappings) --- */
+
+#define sctp_sys_bindx(fd, addrs, num, flags)       usrsctp_bindx(fd, addrs, num, flags)
+#define sctp_sys_connectx(fd, addrs, num, assoc)    usrsctp_connectx(fd, addrs, num, assoc)
+#define sctp_sys_peeloff(fd, assoc)                 usrsctp_peeloff(fd, assoc)
+#define sctp_sys_getpaddrs(fd, assoc, addrs)        usrsctp_getpaddrs(fd, assoc, addrs)
+#define sctp_sys_getladdrs(fd, assoc, addrs)        usrsctp_getladdrs(fd, assoc, addrs)
+#define sctp_sys_freepaddrs(addrs)                  usrsctp_freepaddrs(addrs)
+#define sctp_sys_freeladdrs(addrs)                  usrsctp_freeladdrs(addrs)
+#define sctp_sys_opt_info(fd, assoc, opt, arg, sz)  usrsctp_opt_info(fd, assoc, opt, arg, sz)
+
+/* --- sendv wrapper ---
+ * Native sctp_sendv uses iov+iovlen; usrsctp_sendv uses buf+len.
+ * This wrapper concatenates iov entries if needed.
+ *
+ * usrsctp_sendv only supports a single destination address (addrcnt<=1),
+ * so we cap addrcnt at 1.  This is not a practical limitation: SCTP's
+ * multihoming addresses are exchanged during association setup (INIT/INIT-ACK)
+ * and the stack already knows every peer address.  When sending data the
+ * address parameter only selects which path to use for that message (or NULL
+ * for the primary path), so more than one address is never meaningful.
+ */
+static inline ssize_t sctp_sys_sendv(sctp_sock_t fd, const struct iovec* iov, int iovcnt,
+    struct sockaddr* addrs, int addrcnt, void* info, socklen_t infolen,
+    unsigned int infotype, int flags)
+{
+  if(addrcnt > 1)
+    addrcnt = 1;
+
+  if(iovcnt == 1){
+    return usrsctp_sendv(fd, iov[0].iov_base, iov[0].iov_len,
+        addrs, addrcnt, info, infolen, infotype, flags);
+  }
+
+  /* Multiple iov entries: concatenate into a single buffer */
+  size_t total = 0;
+  int i;
+  ssize_t result;
+  char* buf;
+
+  for(i = 0; i < iovcnt; i++)
+    total += iov[i].iov_len;
+
+  buf = (char*)malloc(total);
+
+  if(!buf){
+    errno = ENOMEM;
+    return -1;
+  }
+
+  {
+    size_t offset = 0;
+    for(i = 0; i < iovcnt; i++){
+      memcpy(buf + offset, iov[i].iov_base, iov[i].iov_len);
+      offset += iov[i].iov_len;
+    }
+  }
+
+  result = usrsctp_sendv(fd, buf, total,
+      addrs, addrcnt, info, infolen, infotype, flags);
+  free(buf);
+  return result;
+}
+
+/* --- recvv wrapper ---
+ * Native sctp_recvv uses iov; usrsctp_recvv uses buf+len.
+ * Assumes iovcnt == 1 (which is how this library uses it).
+ */
+static inline ssize_t sctp_sys_recvv(sctp_sock_t fd, const struct iovec* iov, int iovcnt,
+    struct sockaddr* from, socklen_t* fromlen,
+    void* info, socklen_t* infolen, unsigned int* infotype, int* flags)
+{
+  (void)iovcnt;
+  return usrsctp_recvv(fd, iov[0].iov_base, iov[0].iov_len,
+      from, fromlen, info, infolen, infotype, flags);
+}
+
+/* --- getsockname wrapper ---
+ * usrsctp doesn't have getsockname(); use usrsctp_getladdrs() instead.
+ */
+static inline int sctp_sys_getsockname(sctp_sock_t fd, struct sockaddr* addr, socklen_t* addrlen){
+  struct sockaddr* addrs = NULL;
+  int n = usrsctp_getladdrs(fd, 0, &addrs);
+  socklen_t copy_len;
+
+  if(n <= 0)
+    return -1;
+
+  if(addrs->sa_family == AF_INET6)
+    copy_len = sizeof(struct sockaddr_in6);
+  else
+    copy_len = sizeof(struct sockaddr_in);
+
+  if(copy_len > *addrlen)
+    copy_len = *addrlen;
+
+  memcpy(addr, addrs, copy_len);
+  *addrlen = copy_len;
+  usrsctp_freeladdrs(addrs);
+
+  return 0;
+}
+
+/* --- sctp_send wrapper ---
+ * usrsctp doesn't have sctp_send(); map to usrsctp_sendv with SCTP_SENDV_SNDINFO.
+ */
+static inline ssize_t sctp_sys_send(sctp_sock_t fd, const void* msg, size_t len,
+    const struct sctp_sndrcvinfo* sinfo, int flags)
+{
+  struct sctp_sndinfo sndinfo;
+  memset(&sndinfo, 0, sizeof(sndinfo));
+
+  if(sinfo){
+    sndinfo.snd_sid = sinfo->sinfo_stream;
+    sndinfo.snd_flags = sinfo->sinfo_flags;
+    sndinfo.snd_ppid = sinfo->sinfo_ppid;
+    sndinfo.snd_context = sinfo->sinfo_context;
+    sndinfo.snd_assoc_id = sinfo->sinfo_assoc_id;
+  }
+
+  return usrsctp_sendv(fd, msg, len, NULL, 0,
+      &sndinfo, sizeof(sndinfo), SCTP_SENDV_SNDINFO, flags);
+}
+
+/* --- sctp_sendmsg wrapper ---
+ * Unified interface: takes addrcnt (count of addresses), not byte length.
+ * usrsctp doesn't have sctp_sendmsg(); map to usrsctp_sendv with SCTP_SENDV_SPA.
+ */
+static inline ssize_t sctp_sys_sendmsg(sctp_sock_t fd, const void* msg, size_t len,
+    struct sockaddr* to, int addrcnt,
+    uint32_t ppid, uint32_t flags, uint16_t stream, uint32_t ttl, uint32_t context)
+{
+  struct sctp_sendv_spa spa;
+  memset(&spa, 0, sizeof(spa));
+
+  spa.sendv_sndinfo.snd_sid = stream;
+  spa.sendv_sndinfo.snd_flags = flags;
+  spa.sendv_sndinfo.snd_ppid = ppid;
+  spa.sendv_sndinfo.snd_context = context;
+  spa.sendv_flags = SCTP_SEND_SNDINFO_VALID;
+
+  if(ttl > 0){
+    spa.sendv_prinfo.pr_policy = SCTP_PR_SCTP_TTL;
+    spa.sendv_prinfo.pr_value = ttl;
+    spa.sendv_flags |= SCTP_SEND_PRINFO_VALID;
+  }
+
+  /*
+   * Cap to one destination address — see the comment on sctp_sys_sendv
+   * for why this is not a practical limitation.
+   */
+  if(addrcnt > 1)
+    addrcnt = 1;
+
+  return usrsctp_sendv(fd, msg, len, to, addrcnt,
+      &spa, sizeof(spa), SCTP_SENDV_SPA, 0);
+}
+
+/* --- sctp_recvmsg wrapper ---
+ * usrsctp doesn't have sctp_recvmsg(); map to usrsctp_recvv and translate
+ * the rcvinfo back into an sctp_sndrcvinfo structure.
+ */
+static inline ssize_t sctp_sys_recvmsg(sctp_sock_t fd, void* buf, size_t len,
+    struct sockaddr* from, socklen_t* fromlen,
+    struct sctp_sndrcvinfo* sinfo, int* msg_flags)
+{
+  struct sctp_rcvinfo rcvinfo;
+  socklen_t infolen = sizeof(rcvinfo);
+  unsigned int infotype = 0;
+  ssize_t n;
+
+  /* Ensure rcvinfo is returned */
+  int on = 1;
+  usrsctp_setsockopt(fd, IPPROTO_SCTP, SCTP_RECVRCVINFO, &on, sizeof(on));
+
+  memset(&rcvinfo, 0, sizeof(rcvinfo));
+
+  n = usrsctp_recvv(fd, buf, len, from, fromlen,
+      &rcvinfo, &infolen, &infotype, msg_flags);
+
+  if(n >= 0 && sinfo != NULL){
+    memset(sinfo, 0, sizeof(*sinfo));
+    if(infotype == SCTP_RECVV_RCVINFO){
+      sinfo->sinfo_stream = rcvinfo.rcv_sid;
+      sinfo->sinfo_ssn = rcvinfo.rcv_ssn;
+      sinfo->sinfo_flags = rcvinfo.rcv_flags;
+      sinfo->sinfo_ppid = rcvinfo.rcv_ppid;
+      sinfo->sinfo_tsn = rcvinfo.rcv_tsn;
+      sinfo->sinfo_cumtsn = rcvinfo.rcv_cumtsn;
+      sinfo->sinfo_context = rcvinfo.rcv_context;
+      sinfo->sinfo_assoc_id = rcvinfo.rcv_assoc_id;
+    }
+  }
+
+  return n;
+}
+
+#else
+
+/* =========================================================================
+ * Native kernel SCTP backend (Linux, FreeBSD, etc.)
+ * ========================================================================= */
+
+#include <netinet/sctp.h>
+
+/*
+ * Socket descriptor type: int file descriptor for native SCTP
+ */
+typedef int sctp_sock_t;
+
+/* Convert between Ruby VALUE and socket descriptor */
+#define SCTP_FD_TO_NUM(fd)   INT2NUM(fd)
+#define NUM_TO_SCTP_FD(v)    NUM2INT(v)
+#define SCTP_FD_INVALID(fd)  ((fd) < 0)
+
+/* No-op for native SCTP */
+static inline void sctp_sys_global_init(void){}
+
+/* --- Socket operations: direct pass-through --- */
+
+#define sctp_sys_socket(domain, type, proto)  socket(domain, type, proto)
+#define sctp_sys_close(fd)        close(fd)
+#define sctp_sys_listen(fd, bl)   listen(fd, bl)
+#define sctp_sys_shutdown(fd, h)  shutdown(fd, h)
+
+/* --- Socket options --- */
+
+#define sctp_sys_setsockopt  setsockopt
+#define sctp_sys_getsockopt  getsockopt
+#define sctp_sys_getsockname getsockname
+
+/* --- SCTP operations: direct pass-through --- */
+
+#define sctp_sys_bindx       sctp_bindx
+#define sctp_sys_connectx    sctp_connectx
+#define sctp_sys_peeloff     sctp_peeloff
+#define sctp_sys_getpaddrs   sctp_getpaddrs
+#define sctp_sys_getladdrs   sctp_getladdrs
+#define sctp_sys_freepaddrs  sctp_freepaddrs
+#define sctp_sys_freeladdrs  sctp_freeladdrs
+#define sctp_sys_opt_info    sctp_opt_info
+#define sctp_sys_sendv       sctp_sendv
+#define sctp_sys_recvv       sctp_recvv
+#define sctp_sys_send        sctp_send
+#define sctp_sys_recvmsg     sctp_recvmsg
+
+/* --- sctp_sendmsg wrapper ---
+ * Unified interface: always takes addrcnt (count), not byte length.
+ * On BSD, maps to sctp_sendmsgx (which takes count).
+ * On Linux, maps to sctp_sendmsg (which takes byte length), so we compute it.
+ */
+static inline ssize_t sctp_sys_sendmsg(sctp_sock_t fd, const void* msg, size_t len,
+    struct sockaddr* to, int addrcnt,
+    uint32_t ppid, uint32_t flags, uint16_t stream, uint32_t ttl, uint32_t context)
+{
+#ifdef BSD
+  return sctp_sendmsgx(fd, msg, len, to, addrcnt, ppid, flags, stream, ttl, context);
+#else
+  socklen_t tolen = 0;
+
+  if(to != NULL){
+    if(to->sa_family == AF_INET6)
+      tolen = addrcnt * sizeof(struct sockaddr_in6);
+    else
+      tolen = addrcnt * sizeof(struct sockaddr_in);
+  }
+
+  return sctp_sendmsg(fd, msg, len, to, tolen, ppid, flags, stream, ttl, context);
+#endif
+}
+
+#endif /* HAVE_USRSCTP_H */
+#endif /* SCTP_COMPAT_H */