sctp-socket 0.0.1 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c30fa4f2df555124cafe30c8440c3429b977d0d6dce57b46fbaee7510c096cb4
-  data.tar.gz: 0e008c97688b85e1a2fc27b2af11a5a6262fd755f49aa762e7d6c78fea9ca863
+  metadata.gz: 319cf8cad773727889aed0c51508d4febfa4e145f9572ef2cdc265bdfc4c6ef2
+  data.tar.gz: aa085297b675c4f8a1468d689868a25ff6e9b9f5c954324801146b3878bdb150
 SHA512:
-  metadata.gz: 4f42d5408ad8262084b6df0e6fd199a9dd142fb806f7b603c64a117fd31e2c890ba4090d9c1e04b5491d84e9fb8a77f7d6bc4b39d2da30e982b4fe9d5c17b0a3
-  data.tar.gz: 881f42f26d2f080e2962e9ca01ea179b53ebd13bd956d42b44e626613d7f383208f250c7fb621ae9bddcf3bc95de544db63d08767a70a77d68c1c9bf3205ae75
+  metadata.gz: a26f8069a0034447ceadd4bb5e59af079da161e4ed0d2620de9df1809e072284fa2fc7aea0799f8f1d17f2da74de744ebc4fec399f21f93e0afa713092b5e0ca
+  data.tar.gz: 5267896027a79534c91c52396528654a9f046437ccf437be392d1609fbee72980cfd18116db8e85453048976a990084321089d6159822a5453d4ba155163581f

data/.gitignore

@@ -3,3 +3,4 @@
 *.log
 *.lock
 Makefile
+tmp/

data/CHANGES.md

@@ -1,3 +1,24 @@
-## 24-Nov-2020
+## 0.0.5 - 15-Dec-2021
+* Add handling for Linux platforms that don't support the sctp_sendv function
+  and/or the SCTP_SEND_FAILED_EVENT notification.
+* Some minor updates to Rakefile and Gemfile.
 
+## 0.0.4 - 3-Dec-2020
+* Added the send method. Use this when you already have a connection.
+* Fixed a flags bug in the sendmsg method.
+* Fixed an association_id typo in the connect method.
+* The SCTP_PR_SCTP_TTL flag is automatically set if a TTL value is provided.
+* Added some constants so you can actually start passing flag values.
+
+## 0.0.3 - 1-Dec-2020
+* Added notification hooks that you can subscribe to, so now the subscribe method
+  actually does something.
+
+## 0.0.2 - 29-Nov-2020
+* Fixed the homepage link in the gemspec metadata. Thanks go to Nick LaMuro for the patch.
+* The getlocalnames and getpeernames now return an array of addresses.
+* Added a shutdown method.
+* Added more documentation.
+
+## 0.0.1 - 24-Nov-2020
 * Initial release.

data/Gemfile

@@ -1,10 +1,2 @@
-source 'https://rubygems.org' do
-  group 'test' do
-    gem 'rake'
-    gem 'rspec', '~> 3.9'
-  end
-
-  group 'development' do
-    gem 'rake-compiler', '~> 1.1'
-  end
-end
+source 'https://rubygems.org'
+gemspec

data/README.md

@@ -12,7 +12,7 @@ On some systems, such as RHEL8, you may need to enable the sctp module.
 
 ## Installation
 
-  `gem install sctp-socket`
+`gem install sctp-socket`
 
 ## About SCTP
 
@@ -30,7 +30,7 @@ is applied to correct loss or corruption of data.
 
 ## Synopsis
 
-```
+```ruby
 # sample_server.rb
 require 'sctp/socket'
 
@@ -43,7 +43,7 @@ begin
   socket.listen
 
   while true
-    data = socket.recvmsgx
+    data = socket.recvmsg
     puts data
   end
 ensure
@@ -53,15 +53,28 @@ end
 
 ## Future Plans
 
-* Check for notification data and return it if encountered.
-* Add specs.
+* Add more constants.
+* Add more specs.
+* Add more notifications.
 
 ## Known Issues
 
+Currently this has only been developed and tested on Linux. Other platforms
+will probably only be supported via community contributions.
+
+On Ubuntu 20 and possibly other Linux variants, the sendv method is not
+available. Use the sendmsg method instead.
+
 Please report any issues on the github project page.
 
   https://github.com/djberg96/sctp-socket
 
+## More Information on SCTP
+
+* https://www.linuxjournal.com/article/9748
+* https://www.linuxjournal.com/article/9749
+* https://www.linuxjournal.com/article/9784
+
 ## License
 
 Apache-2.0

data/Rakefile

@@ -6,20 +6,21 @@ require 'rake/extensiontask'
 include RbConfig
 
 CLEAN.include(
-  '**/*.gem',               # Gem files
-  '**/*.rbc',               # Rubinius
-  '**/*.o',                 # C object file
-  '**/*.log',               # Ruby extension build log
-  '**/Makefile',            # C Makefile
-  '**/conftest.dSYM',       # OS X build directory
-  "**/*.#{CONFIG['DLEXT']}" # C shared object
+  '**/*.gem',                # Gem files
+  '**/*.rbc',                # Rubinius
+  '**/*.o',                  # C object file
+  '**/*.log',                # Ruby extension build log
+  '**/Makefile',             # C Makefile
+  '**/conftest.dSYM',        # OS X build directory
+  "**/*.#{CONFIG['DLEXT']}", # C shared object
+  'tmp'                      # Rake compiler
 )
 
 namespace :gem do
   desc "Create the sys-uname gem"
   task :create => [:clean] do
     require 'rubygems/package'
-    spec = eval(IO.read('sctp-socket.gemspec'))
+    spec = Gem::Specification.load('sctp-socket.gemspec')
     spec.signing_key = File.join(Dir.home, '.ssh', 'gem-private_key.pem')
     Gem::Package.build(spec)
   end
@@ -39,4 +40,4 @@ end
 RSpec::Core::RakeTask.new
 
 task :spec => :compile
-task :default => :spec
+task :default => [:clean, :spec]

data/ext/sctp/extconf.rb

@@ -2,4 +2,6 @@ require 'mkmf'
 
 have_header('netinet/sctp.h')
 have_library('sctp')
+have_func('sctp_sendv', 'netinet/sctp.h')
+have_struct_member('struct sctp_event_subscribe', 'sctp_send_failure_event', 'netinet/sctp.h')
 create_makefile('sctp/socket')

data/ext/sctp/socket.c

@@ -7,6 +7,61 @@
 VALUE mSCTP;
 VALUE cSocket;
 VALUE v_sndrcv_struct;
+VALUE v_assoc_change_struct;
+VALUE v_peeraddr_change_struct;
+VALUE v_remote_error_struct;
+VALUE v_send_failed_event_struct;
+VALUE v_shutdown_event_struct;
+VALUE v_sndinfo_struct;
+VALUE v_adaptation_event_struct;
+VALUE v_partial_delivery_event_struct;
+VALUE v_auth_event_struct;
+VALUE v_sockaddr_in_struct;
+VALUE v_sctp_status_struct;
+VALUE v_sctp_rtoinfo_struct;
+VALUE v_sctp_associnfo_struct;
+VALUE v_sctp_default_send_params_struct;
+
+#if !defined(IOV_MAX)
+#if defined(_SC_IOV_MAX)
+#define IOV_MAX (sysconf(_SC_IOV_MAX))
+#else
+// Assume infinity, or let the syscall return with error
+#define IOV_MAX INT_MAX
+#endif
+#endif
+
+#define ARY2IOVEC(iov,ary) \
+   do { \
+      VALUE *cur; \
+      struct iovec *tmp; \
+      long n; \
+      cur = RARRAY_PTR(ary); \
+      n = RARRAY_LEN(ary); \
+      iov = tmp = alloca(sizeof(struct iovec) * n); \
+      for (; --n >= 0; tmp++, cur++) { \
+         if (TYPE(*cur) != T_STRING) \
+            rb_raise(rb_eArgError, "must be an array of strings"); \
+         tmp->iov_base = RSTRING_PTR(*cur); \
+         tmp->iov_len = RSTRING_LEN(*cur); \
+      } \
+   } while (0)
+
+// TODO: Yes, I know I need to update the signature.
+VALUE convert_sockaddr_in_to_struct(struct sockaddr_in* addr){
+  char ipbuf[INET6_ADDRSTRLEN];
+
+  if(addr->sin_family == AF_INET6)
+    inet_ntop(addr->sin_family, &(((struct sockaddr_in6 *)addr)->sin6_addr), ipbuf, sizeof(ipbuf));
+  else
+    inet_ntop(addr->sin_family, &(((struct sockaddr_in *)addr)->sin_addr), ipbuf, sizeof(ipbuf));
+
+  return rb_struct_new(v_sockaddr_in_struct,
+    INT2NUM(addr->sin_family),
+    INT2NUM(ntohs(addr->sin_port)),
+    rb_str_new2(ipbuf)
+  );
+}
 
 // Helper function to get a hash value via string or symbol.
 VALUE rb_hash_aref2(VALUE v_hash, const char* key){
@@ -26,8 +81,15 @@ VALUE rb_hash_aref2(VALUE v_hash, const char* key){
  * a domain (aka family) value and socket type. By default these are AF_INET
  * and SOCK_SEQPACKET, respectively.
  *
+ * There are only two supported families: SOCK_SEQPACKET for the creation
+ * of a one-to-many socket, and SOCK_STREAM for the creation of a
+ * one-to-one socket.
+ *
  * Example:
  *
+ *   require 'socket'
+ *   require 'sctp/socket'
+ *
  *   socket1 = SCTP::Socket.new
  *   socket2 = SCTP::Socket.new(Socket::AF_INET, Socket::SOCK_STREAM)
  */
@@ -193,7 +255,7 @@ static VALUE rsctp_connect(int argc, VALUE* argv, VALUE self){
   if(sctp_connectx(sock_fd, (struct sockaddr *) addrs, num_ip, &assoc) < 0)
     rb_raise(rb_eSystemCallError, "sctp_connectx: %s", strerror(errno));
 
-  rb_iv_set(self, "@assocation_id", INT2NUM(assoc));
+  rb_iv_set(self, "@association_id", INT2NUM(assoc));
 
   return self;
 }
@@ -215,16 +277,20 @@ static VALUE rsctp_close(VALUE self){
   return self;
 }
 
+/*
+ *  Return an array of all addresses of a peer.
+ */
 static VALUE rsctp_getpeernames(VALUE self){
-  VALUE v_assoc_id = rb_iv_get(self, "@assocation_id"); 
   sctp_assoc_t assoc_id;
   struct sockaddr* addrs;
   int i, sock_fd, num_addrs;
+  char str[16];
+  VALUE v_array = rb_ary_new();
 
   bzero(&addrs, sizeof(addrs));
 
   sock_fd = NUM2INT(rb_iv_get(self, "@sock_fd"));
-  assoc_id = NUM2INT(v_assoc_id);
+  assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
 
   num_addrs = sctp_getpaddrs(sock_fd, assoc_id, &addrs);
 
@@ -234,23 +300,36 @@ static VALUE rsctp_getpeernames(VALUE self){
   }
 
   for(i = 0; i < num_addrs; i++){
-    // TODO: Create and return array of IpAddr objects
+    inet_ntop(AF_INET, &(((struct sockaddr_in *)&addrs[i])->sin_addr), str, sizeof(str));
+    rb_ary_push(v_array, rb_str_new2(str));
+    bzero(&str, sizeof(str));
   }
 
   sctp_freepaddrs(addrs);
 
-  return self;
+  return v_array;
 }
 
+/*
+ * Return an array of local addresses that are part of the association.
+ *
+ * Example:
+ *
+ *  socket = SCTP::Socket.new
+ *  socket.bind(:addresses => ['10.0.4.5', '10.0.5.5'])
+ *  socket.getlocalnames # => ['10.0.4.5', '10.0.5.5'])
+ */
 static VALUE rsctp_getlocalnames(VALUE self){
   sctp_assoc_t assoc_id;
   struct sockaddr* addrs;
   int i, sock_fd, num_addrs;
+  char str[16];
+  VALUE v_array = rb_ary_new();
 
   bzero(&addrs, sizeof(addrs));
 
   sock_fd = NUM2INT(rb_iv_get(self, "@sock_fd"));
-  assoc_id = NUM2INT(rb_iv_get(self, "@assocation_id"));
+  assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
 
   num_addrs = sctp_getladdrs(sock_fd, assoc_id, &addrs);
 
@@ -260,12 +339,152 @@ static VALUE rsctp_getlocalnames(VALUE self){
   }
 
   for(i = 0; i < num_addrs; i++){
-    // TODO: Create and return array of IpAddr objects
+    inet_ntop(AF_INET, &(((struct sockaddr_in *)&addrs[i])->sin_addr), str, sizeof(str));
+    rb_ary_push(v_array, rb_str_new2(str));
+    bzero(&str, sizeof(str));
   }
 
   sctp_freeladdrs(addrs);
 
-  return self;
+  return v_array;
+}
+
+#ifdef HAVE_SCTP_SENDV
+static VALUE rsctp_sendv(VALUE self, VALUE v_messages){
+  struct iovec* iov;
+  struct sockaddr* addrs[8];
+  struct sctp_sndinfo info;
+  int sock_fd, num_bytes, size;
+
+  Check_Type(v_messages, T_ARRAY);
+  bzero(&addrs, sizeof(addrs));
+
+  sock_fd = NUM2INT(rb_iv_get(self, "@sock_fd"));
+
+  Check_Type(v_messages, T_ARRAY);
+  size = RARRAY_LEN(v_messages);
+
+  if(!size)
+    rb_raise(rb_eArgError, "Must contain at least one message");
+
+  if(size > IOV_MAX)
+    rb_raise(rb_eArgError, "Array size is greater than IOV_MAX");
+
+  ARY2IOVEC(iov, v_messages);
+
+  info.snd_flags = SCTP_UNORDERED;
+  info.snd_assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
+
+  num_bytes = sctp_sendv(
+    sock_fd,
+    iov,
+    size,
+    NULL,
+    0,
+    &info,
+    sizeof(info),
+    SCTP_SENDV_SNDINFO,
+    0
+  );
+
+  if(num_bytes < 0)
+    rb_raise(rb_eSystemCallError, "sctp_sendv: %s", strerror(errno));
+
+  return INT2NUM(num_bytes);
+}
+#endif
+
+/*
+ * Send a message on an already-connected socket to a specific association.
+ *
+ * Example:
+ *
+ *   socket = SCTP::Socket.new
+ *   socket.connect(:port => 42000, :addresses => ['10.0.4.5', '10.0.5.5'])
+ *
+ *   socket.send(:message => "Hello World")
+ *   socket.send(:message => "Hello World", :association_id => 37)
+ *
+ */
+static VALUE rsctp_send(VALUE self, VALUE v_options){
+  uint16_t stream;
+  uint32_t ppid, send_flags, ctrl_flags, ttl, context;
+  ssize_t num_bytes;
+  int sock_fd;
+  sctp_assoc_t assoc_id;
+  struct sctp_sndrcvinfo info;
+  VALUE v_msg, v_stream, v_ppid, v_context, v_send_flags, v_ctrl_flags, v_ttl, v_assoc_id;
+
+  Check_Type(v_options, T_HASH);
+
+  v_msg        = rb_hash_aref2(v_options, "message");
+  v_stream     = rb_hash_aref2(v_options, "stream");
+  v_ppid       = rb_hash_aref2(v_options, "ppid");
+  v_context    = rb_hash_aref2(v_options, "context");
+  v_send_flags = rb_hash_aref2(v_options, "send_flags");
+  v_ctrl_flags = rb_hash_aref2(v_options, "control_flags");
+  v_ttl        = rb_hash_aref2(v_options, "ttl");
+  v_assoc_id   = rb_hash_aref2(v_options, "association_id");
+
+  if(NIL_P(v_stream))
+    stream = 0;
+  else
+    stream = NUM2INT(v_stream);
+
+  if(NIL_P(v_send_flags))
+    send_flags = 0;
+  else
+    send_flags = NUM2INT(v_send_flags);
+
+  if(NIL_P(v_ctrl_flags))
+    ctrl_flags = 0;
+  else
+    ctrl_flags = NUM2INT(v_ctrl_flags);
+
+  if(NIL_P(v_ttl)){
+    ttl = 0;
+  }
+  else{
+    ttl = NUM2INT(v_ttl);
+    send_flags |= SCTP_PR_SCTP_TTL;
+  }
+
+  if(NIL_P(v_ppid))
+    ppid = 0;
+  else
+    ppid = NUM2INT(v_ppid);
+
+  if(NIL_P(v_context))
+    context = 0;
+  else
+    context = NUM2INT(v_context);
+
+  if(NIL_P(v_assoc_id))
+    assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
+  else
+    assoc_id = NUM2INT(v_assoc_id);
+
+  info.sinfo_stream = stream;
+  info.sinfo_flags = send_flags;
+  info.sinfo_ppid = ppid;
+  info.sinfo_context = context;
+  info.sinfo_timetolive = ttl;
+  info.sinfo_assoc_id = assoc_id;
+
+  sock_fd = NUM2INT(rb_iv_get(self, "@sock_fd"));
+
+  num_bytes = sctp_send(
+    sock_fd,
+    StringValueCStr(v_msg),
+    RSTRING_LEN(v_msg),
+    &info,
+    ctrl_flags
+  );
+
+  if(num_bytes < 0)
+    rb_raise(rb_eSystemCallError, "sctp_send: %s", strerror(errno));
+
+  return INT2NUM(num_bytes);
 }
 
 /*
@@ -323,12 +542,15 @@ static VALUE rsctp_sendmsg(VALUE self, VALUE v_options){
   if(NIL_P(v_flags))
     flags = 0;
   else
-    flags = NUM2INT(v_stream);
+    flags = NUM2INT(v_flags);
 
-  if(NIL_P(v_ttl))
+  if(NIL_P(v_ttl)){
     ttl = 0;
-  else
+  }
+  else{
     ttl = NUM2INT(v_ttl);
+    flags |= SCTP_PR_SCTP_TTL;
+  }
 
   if(NIL_P(v_ppid))
     ppid = 0;
@@ -406,7 +628,7 @@ static VALUE rsctp_sendmsg(VALUE self, VALUE v_options){
  *   end
  */
 static VALUE rsctp_recvmsg(int argc, VALUE* argv, VALUE self){
-  VALUE v_flags;
+  VALUE v_flags, v_notification, v_message;
   struct sctp_sndrcvinfo sndrcvinfo;
   struct sockaddr_in clientaddr;
   int flags, bytes, sock_fd;
@@ -437,49 +659,215 @@ static VALUE rsctp_recvmsg(int argc, VALUE* argv, VALUE self){
   if(bytes < 0)
     rb_raise(rb_eSystemCallError, "sctp_recvmsg: %s", strerror(errno));
 
-  // TODO: Check for MSG_NOTIFICATION, return different structs for events.
-  /*
+  v_notification = Qnil;
+
   if(flags & MSG_NOTIFICATION){
+    uint32_t i;
+    char str[16];
     union sctp_notification* snp;
+    VALUE v_str;
+    VALUE* v_temp;
+
     snp = (union sctp_notification*)buffer;
 
-    switch(snp->sn_type){
+    switch(snp->sn_header.sn_type){
       case SCTP_ASSOC_CHANGE:
+        switch(snp->sn_assoc_change.sac_state){
+          case SCTP_COMM_LOST:
+            v_str = rb_str_new2("comm lost");
+            break;
+          case SCTP_COMM_UP:
+            v_str = rb_str_new2("comm up");
+            break;
+          case SCTP_RESTART:
+            v_str = rb_str_new2("restart");
+            break;
+          case SCTP_SHUTDOWN_COMP:
+            v_str = rb_str_new2("shutdown complete");
+            break;
+          case SCTP_CANT_STR_ASSOC:
+            v_str = rb_str_new2("association setup failed");
+            break;
+          default:
+            v_str = rb_str_new2("unknown");
+        }
+
+        v_notification = rb_struct_new(v_assoc_change_struct,
+          UINT2NUM(snp->sn_assoc_change.sac_type),
+          UINT2NUM(snp->sn_assoc_change.sac_length),
+          UINT2NUM(snp->sn_assoc_change.sac_state),
+          UINT2NUM(snp->sn_assoc_change.sac_error),
+          UINT2NUM(snp->sn_assoc_change.sac_outbound_streams),
+          UINT2NUM(snp->sn_assoc_change.sac_inbound_streams),
+          UINT2NUM(snp->sn_assoc_change.sac_assoc_id),
+          v_str
+        );
         break;
       case SCTP_PEER_ADDR_CHANGE:
+        switch(snp->sn_paddr_change.spc_state){
+          case SCTP_ADDR_AVAILABLE:
+            v_str = rb_str_new2("available");
+            break;
+          case SCTP_ADDR_UNREACHABLE:
+            v_str = rb_str_new2("unreachable");
+            break;
+          case SCTP_ADDR_REMOVED:
+            v_str = rb_str_new2("removed from association");
+            break;
+          case SCTP_ADDR_ADDED:
+            v_str = rb_str_new2("added to association");
+            break;
+          case SCTP_ADDR_MADE_PRIM:
+            v_str = rb_str_new2("primary destination");
+            break;
+          default:
+            v_str = rb_str_new2("unknown");
+        }
+
+        inet_ntop(
+          ((struct sockaddr_in *)&snp->sn_paddr_change.spc_aaddr)->sin_family,
+          &(((struct sockaddr_in *)&snp->sn_paddr_change.spc_aaddr)->sin_addr),
+          str,
+          sizeof(str)
+        );
+
+        v_notification = rb_struct_new(v_peeraddr_change_struct,
+          UINT2NUM(snp->sn_paddr_change.spc_type),
+          UINT2NUM(snp->sn_paddr_change.spc_length),
+          rb_str_new2(str),
+          UINT2NUM(snp->sn_paddr_change.spc_state),
+          UINT2NUM(snp->sn_paddr_change.spc_error),
+          UINT2NUM(snp->sn_paddr_change.spc_assoc_id),
+          v_str
+        );
         break;
       case SCTP_REMOTE_ERROR:
+        v_temp = ALLOCA_N(VALUE, snp->sn_remote_error.sre_length);
+
+        for(i = 0; i < snp->sn_remote_error.sre_length; i++){
+          v_temp[i] = UINT2NUM(snp->sn_remote_error.sre_data[i]);
+        }
+
+        v_notification = rb_struct_new(v_remote_error_struct,
+          UINT2NUM(snp->sn_remote_error.sre_type),
+          UINT2NUM(snp->sn_remote_error.sre_length),
+          UINT2NUM(snp->sn_remote_error.sre_error),
+          UINT2NUM(snp->sn_remote_error.sre_assoc_id),
+          rb_ary_new4(snp->sn_remote_error.sre_length, v_temp)
+        );
+        break;
+#ifdef SCTP_SEND_FAILED_EVENT
+      case SCTP_SEND_FAILED_EVENT:
+        v_temp = ALLOCA_N(VALUE, snp->sn_send_failed_event.ssf_length);
+
+        for(i = 0; i < snp->sn_send_failed_event.ssf_length; i++){
+          v_temp[i] = UINT2NUM(snp->sn_send_failed_event.ssf_data[i]);
+        }
+
+        v_notification = rb_struct_new(v_send_failed_event_struct,
+          UINT2NUM(snp->sn_send_failed_event.ssf_type),
+          UINT2NUM(snp->sn_send_failed_event.ssf_length),
+          UINT2NUM(snp->sn_send_failed_event.ssf_error),
+          rb_struct_new(v_sndinfo_struct,
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_sid),
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_flags),
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_ppid),
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_context),
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_assoc_id)
+          ),
+          UINT2NUM(snp->sn_send_failed_event.ssf_assoc_id),
+          rb_ary_new4(snp->sn_send_failed_event.ssf_length, v_temp)
+        );
         break;
+#else
       case SCTP_SEND_FAILED:
+        v_temp = ALLOCA_N(VALUE, snp->sn_send_failed.ssf_length);
+
+        for(i = 0; i < snp->sn_send_failed.ssf_length; i++){
+          v_temp[i] = UINT2NUM(snp->sn_send_failed.ssf_data[i]);
+        }
+
+        v_notification = rb_struct_new(v_send_failed_event_struct,
+          UINT2NUM(snp->sn_send_failed.ssf_type),
+          UINT2NUM(snp->sn_send_failed.ssf_length),
+          UINT2NUM(snp->sn_send_failed.ssf_error),
+          Qnil,
+          UINT2NUM(snp->sn_send_failed.ssf_assoc_id),
+          rb_ary_new4(snp->sn_send_failed.ssf_length, v_temp)
+        );
         break;
+#endif
       case SCTP_SHUTDOWN_EVENT:
+        v_notification = rb_struct_new(v_shutdown_event_struct,
+          UINT2NUM(snp->sn_shutdown_event.sse_type),
+          UINT2NUM(snp->sn_shutdown_event.sse_length),
+          UINT2NUM(snp->sn_shutdown_event.sse_assoc_id)
+        );
         break;
       case SCTP_ADAPTATION_INDICATION:
+        v_notification = rb_struct_new(v_adaptation_event_struct,
+          UINT2NUM(snp->sn_adaptation_event.sai_type),
+          UINT2NUM(snp->sn_adaptation_event.sai_length),
+          UINT2NUM(snp->sn_adaptation_event.sai_adaptation_ind),
+          UINT2NUM(snp->sn_adaptation_event.sai_assoc_id)
+        );
         break;
       case SCTP_PARTIAL_DELIVERY_EVENT:
+        v_notification = rb_struct_new(v_partial_delivery_event_struct,
+          UINT2NUM(snp->sn_pdapi_event.pdapi_type),
+          UINT2NUM(snp->sn_pdapi_event.pdapi_length),
+          UINT2NUM(snp->sn_pdapi_event.pdapi_indication),
+          UINT2NUM(snp->sn_pdapi_event.pdapi_stream),
+          UINT2NUM(snp->sn_pdapi_event.pdapi_seq),
+          UINT2NUM(snp->sn_pdapi_event.pdapi_assoc_id)
+        );
+        break;
+      case SCTP_AUTHENTICATION_EVENT:
+        v_notification = rb_struct_new(v_auth_event_struct,
+          UINT2NUM(snp->sn_authkey_event.auth_type),
+          UINT2NUM(snp->sn_authkey_event.auth_length),
+          UINT2NUM(snp->sn_authkey_event.auth_keynumber),
+          UINT2NUM(snp->sn_authkey_event.auth_indication),
+          UINT2NUM(snp->sn_authkey_event.auth_assoc_id)
+        );
         break;
     }
   }
-  */
+
+  if(NIL_P(v_notification))
+    v_message = rb_str_new(buffer, bytes);
+  else
+    v_message = Qnil;
 
   return rb_struct_new(v_sndrcv_struct,
-    rb_str_new(buffer, bytes),
+    v_message,
     UINT2NUM(sndrcvinfo.sinfo_stream),
     UINT2NUM(sndrcvinfo.sinfo_flags),
     UINT2NUM(sndrcvinfo.sinfo_ppid),
     UINT2NUM(sndrcvinfo.sinfo_context),
     UINT2NUM(sndrcvinfo.sinfo_timetolive),
-    UINT2NUM(sndrcvinfo.sinfo_assoc_id)
+    UINT2NUM(sndrcvinfo.sinfo_assoc_id),
+    v_notification,
+    convert_sockaddr_in_to_struct(&clientaddr)
   );
 }
 
 /*
- *  {
- *    :output_streams => 2,
- *    :input_streams  => 3,
- *    :max_attempts   => 5,
- *    :timeout        => 30
- *  }
+ * Set the initial parameters used by the socket when sending out the INIT message.
+ *
+ * Example:
+ *
+ *  socket = SCTP::Socket.new
+ *  socket.set_initmsg(:output_streams => 5, :input_streams => 5, :max_attempts => 4, :timeout => 30)
+ *
+ * The following parameters can be configured:
+ *
+ * :output_streams - The number of outbound SCTP streams an application would like to request.
+ * :input_streams - The maximum number of inbound streams an application is prepared to allow.
+ * :max_attempts - How many times the the SCTP stack should send the initial INIT message before it's considered unreachable.
+ * :timeout - The maximum RTO value for the INIT timer.
+ *
+ * By default these values are set to zero (i.e. ignored).
  */
 static VALUE rsctp_set_initmsg(VALUE self, VALUE v_options){
   int sock_fd;
@@ -519,7 +907,7 @@ static VALUE rsctp_set_initmsg(VALUE self, VALUE v_options){
  * as follows:
  *
  *   :association
- *   - A change has occurred to an assocation, either a new one has begun or an existing one has end.
+ *   - A change has occurred to an association, either a new one has begun or an existing one has end.
  *
  *   :address
  *   - The state of one of the peer's addresses has experienced a change.
@@ -530,14 +918,19 @@ static VALUE rsctp_set_initmsg(VALUE self, VALUE v_options){
  *   :shutdown
  *   - The peer has sent a shutdown to the local endpoint.
  *
+ *   :data_io
+ *   - Message data was received. On by default.
+ *
  *   Others:
  *
- *   :adaptation_layer
- *   :authentication_event
- *   :data_io
- *   :peer_error
+ *   :adaptation
+ *   :authentication
  *   :partial_delivery
+ *
+ *   Not yet supported:
+ *
  *   :sender_dry
+ *   :peer_error
  *
  * By default only data_io is subscribed to.
  *
@@ -565,7 +958,11 @@ static VALUE rsctp_subscribe(VALUE self, VALUE v_options){
     events.sctp_address_event = 1;
 
   if(RTEST(rb_hash_aref2(v_options, "send_failure")))
+#ifdef HAVE_STRUCT_SCTP_EVENT_SUBSCRIBE_SCTP_SEND_FAILURE_EVENT
     events.sctp_send_failure_event = 1;
+#else
+    events.sctp_send_failure_event_event = 1;
+#endif
 
   if(RTEST(rb_hash_aref2(v_options, "peer_error")))
     events.sctp_peer_error_event = 1;
@@ -645,13 +1042,220 @@ static VALUE rsctp_peeloff(VALUE self, VALUE v_assoc_id){
   return self;
 }
 
+static VALUE rsctp_get_default_send_params(VALUE self){
+  int sock_fd;
+  socklen_t size;
+  sctp_assoc_t assoc_id;
+  struct sctp_sndrcvinfo sndrcv;
+
+  bzero(&sndrcv, sizeof(sndrcv));
+
+  sock_fd = NUM2INT(rb_iv_get(self, "@sock_fd"));
+  assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
+  size = sizeof(struct sctp_sndrcvinfo);
+
+  if(sctp_opt_info(sock_fd, assoc_id, SCTP_DEFAULT_SEND_PARAM, (void*)&sndrcv, &size) < 0)
+    rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
+
+  return rb_struct_new(
+    v_sctp_default_send_params_struct,
+    INT2NUM(sndrcv.sinfo_stream),
+    INT2NUM(sndrcv.sinfo_ssn),
+    INT2NUM(sndrcv.sinfo_flags),
+    INT2NUM(sndrcv.sinfo_ppid),
+    INT2NUM(sndrcv.sinfo_context),
+    INT2NUM(sndrcv.sinfo_timetolive),
+    INT2NUM(sndrcv.sinfo_tsn),
+    INT2NUM(sndrcv.sinfo_cumtsn),
+    INT2NUM(sndrcv.sinfo_assoc_id)
+  );
+}
+
+static VALUE rsctp_get_association_info(VALUE self){
+  int sock_fd;
+  socklen_t size;
+  sctp_assoc_t assoc_id;
+  struct sctp_assocparams assoc;
+
+  bzero(&assoc, sizeof(assoc));
+
+  sock_fd = NUM2INT(rb_iv_get(self, "@sock_fd"));
+  assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
+  size = sizeof(struct sctp_assocparams);
+
+  if(sctp_opt_info(sock_fd, assoc_id, SCTP_ASSOCINFO, (void*)&assoc, &size) < 0)
+    rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
+
+  return rb_struct_new(
+    v_sctp_associnfo_struct,
+    INT2NUM(assoc.sasoc_assoc_id),
+    INT2NUM(assoc.sasoc_asocmaxrxt),
+    INT2NUM(assoc.sasoc_number_peer_destinations),
+    INT2NUM(assoc.sasoc_peer_rwnd),
+    INT2NUM(assoc.sasoc_local_rwnd),
+    INT2NUM(assoc.sasoc_cookie_life)
+  );
+}
+
+static VALUE rsctp_shutdown(int argc, VALUE* argv, VALUE self){
+  int how, sock_fd;
+  VALUE v_how;
+
+  sock_fd = NUM2INT(rb_iv_get(self, "@sock_fd"));
+
+  rb_scan_args(argc, argv, "01", &v_how);
+
+  if(NIL_P(v_how)){
+    how = SHUT_RDWR;
+  }
+  else{
+    Check_Type(v_how, T_FIXNUM);
+    how = NUM2INT(v_how);
+  }
+
+  if(shutdown(sock_fd, how) < 0)
+    rb_raise(rb_eSystemCallError, "shutdown: %s", strerror(errno));
+
+  return self;
+}
+
+static VALUE rsctp_get_retransmission_info(VALUE self){
+  int sock_fd;
+  socklen_t size;
+  sctp_assoc_t assoc_id;
+  struct sctp_rtoinfo rto;
+
+  bzero(&rto, sizeof(rto));
+
+  sock_fd = NUM2INT(rb_iv_get(self, "@sock_fd"));
+  assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
+  size = sizeof(struct sctp_rtoinfo);
+
+  if(sctp_opt_info(sock_fd, assoc_id, SCTP_RTOINFO, (void*)&rto, &size) < 0)
+    rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
+
+  return rb_struct_new(
+    v_sctp_rtoinfo_struct,
+    INT2NUM(rto.srto_assoc_id),
+    INT2NUM(rto.srto_initial),
+    INT2NUM(rto.srto_max),
+    INT2NUM(rto.srto_min)
+  );
+}
+
+static VALUE rsctp_get_status(VALUE self){
+  int sock_fd;
+  socklen_t size;
+  sctp_assoc_t assoc_id;
+  struct sctp_status status;
+  struct sctp_paddrinfo* spinfo;
+  char tmpname[INET_ADDRSTRLEN];
+
+  bzero(&status, sizeof(status));
+
+  sock_fd = NUM2INT(rb_iv_get(self, "@sock_fd"));
+  assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
+  size = sizeof(struct sctp_status);
+
+  if(sctp_opt_info(sock_fd, assoc_id, SCTP_STATUS, (void*)&status, &size) < 0)
+    rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
+
+  spinfo = &status.sstat_primary;
+
+  if (spinfo->spinfo_address.ss_family == AF_INET6) {
+		struct sockaddr_in6 *sin6;
+		sin6 = (struct sockaddr_in6 *)&spinfo->spinfo_address;
+		inet_ntop(AF_INET6, &sin6->sin6_addr, tmpname, sizeof (tmpname));
+	}
+  else {
+		struct sockaddr_in *sin;
+		sin = (struct sockaddr_in *)&spinfo->spinfo_address;
+		inet_ntop(AF_INET, &sin->sin_addr, tmpname, sizeof (tmpname));
+  }
+
+  return rb_struct_new(v_sctp_status_struct,
+    INT2NUM(status.sstat_assoc_id),
+    INT2NUM(status.sstat_state),
+    INT2NUM(status.sstat_rwnd),
+    INT2NUM(status.sstat_unackdata),
+    INT2NUM(status.sstat_penddata),
+    INT2NUM(status.sstat_instrms),
+    INT2NUM(status.sstat_outstrms),
+    INT2NUM(status.sstat_fragmentation_point),
+    rb_str_new2(tmpname)
+  );
+}
+
 void Init_socket(){
   mSCTP   = rb_define_module("SCTP");
   cSocket = rb_define_class_under(mSCTP, "Socket", rb_cObject);
 
   v_sndrcv_struct = rb_struct_define(
-    "SndRecvInfo", "message", "stream", "flags",
-    "ppid", "context", "ttl", "assoc_id", NULL
+    "SendReceiveInfo", "message", "stream", "flags",
+    "ppid", "context", "ttl", "association_id", "notification", "client", NULL
+  );
+
+  v_assoc_change_struct = rb_struct_define(
+    "AssocChange", "type", "length", "state", "error",
+    "outbound_streams", "inbound_streams", "association_id", "info", NULL
+  );
+
+  v_peeraddr_change_struct = rb_struct_define(
+    "PeerAddrChange", "type", "length", "ip_address",
+    "state", "error", "association_id", "info", NULL
+  );
+
+  v_remote_error_struct = rb_struct_define(
+    "RemoteError", "type", "length", "error", "association_id", "data", NULL
+  );
+
+  v_send_failed_event_struct = rb_struct_define(
+    "SendFailedEvent", "type", "length", "error", "association_id", "data", NULL
+  );
+
+  v_shutdown_event_struct = rb_struct_define(
+    "ShutdownEvent", "type", "length", "association_id", NULL
+  );
+
+  v_sndinfo_struct = rb_struct_define(
+    "SendInfo", "sid", "flags", "ppid", "context", "association_id", NULL
+  );
+
+  v_adaptation_event_struct = rb_struct_define(
+    "AdaptationEvent", "type", "length", "adaptation_indication", "association_id", NULL
+  );
+
+  v_partial_delivery_event_struct = rb_struct_define(
+    "PartialDeliveryEvent", "type", "length", "indication", "stream",
+    "sequence_number", "association_id", NULL
+  );
+
+  v_auth_event_struct = rb_struct_define(
+    "AuthEvent", "type", "length", "key_number", "indication", "association_id", NULL
+  );
+
+  v_sockaddr_in_struct = rb_struct_define(
+    "SockAddrIn", "family", "port", "address", NULL
+  );
+
+  v_sctp_status_struct = rb_struct_define(
+    "Status", "association_id", "state", "receive_window", "unacknowledged_data",
+    "pending_data", "inbound_streams", "outbound_streams", "fragmentation_point", "primary", NULL
+  );
+
+  v_sctp_rtoinfo_struct = rb_struct_define(
+    "RetransmissionInfo", "association_id", "initial", "max", "min", NULL
+  );
+
+  v_sctp_associnfo_struct = rb_struct_define(
+    "AssociationInfo", "association_id", "max_retransmission_count",
+    "number_peer_destinations", "peer_receive_window", "local_receive_window",
+    "cookie_life", NULL
+  );
+
+  v_sctp_default_send_params_struct = rb_struct_define(
+    "DefaultSendParams", "stream", "ssn", "flags", "ppid", "context",
+    "ttl", "tsn", "cumtsn", "association_id", NULL
   );
 
   rb_define_method(cSocket, "initialize", rsctp_init, -1);
@@ -661,11 +1265,22 @@ void Init_socket(){
   rb_define_method(cSocket, "connect", rsctp_connect, -1);
   rb_define_method(cSocket, "getpeernames", rsctp_getpeernames, 0);
   rb_define_method(cSocket, "getlocalnames", rsctp_getlocalnames, 0);
+  rb_define_method(cSocket, "get_status", rsctp_get_status, 0);
+  rb_define_method(cSocket, "get_default_send_params", rsctp_get_default_send_params, 0);
+  rb_define_method(cSocket, "get_retransmission_info", rsctp_get_retransmission_info, 0);
+  rb_define_method(cSocket, "get_association_info", rsctp_get_association_info, 0);
   rb_define_method(cSocket, "listen", rsctp_listen, -1);
   rb_define_method(cSocket, "peeloff!", rsctp_peeloff, 1);
   rb_define_method(cSocket, "recvmsg", rsctp_recvmsg, -1);
+  rb_define_method(cSocket, "send", rsctp_send, 1);
+
+#ifdef HAVE_SCTP_SENDV
+  rb_define_method(cSocket, "sendv", rsctp_sendv, 1);
+#endif
+
   rb_define_method(cSocket, "sendmsg", rsctp_sendmsg, 1);
   rb_define_method(cSocket, "set_initmsg", rsctp_set_initmsg, 1);
+  rb_define_method(cSocket, "shutdown", rsctp_shutdown, -1);
   rb_define_method(cSocket, "subscribe", rsctp_subscribe, 1);
 
   rb_define_attr(cSocket, "domain", 1, 1);
@@ -674,6 +1289,37 @@ void Init_socket(){
   rb_define_attr(cSocket, "association_id", 1, 1);
   rb_define_attr(cSocket, "port", 1, 1);
 
-  /* 0.0.1: The version of this library */
-  rb_define_const(cSocket, "VERSION", rb_str_new2("0.0.1"));
+  /* 0.0.5: The version of this library */
+  rb_define_const(cSocket, "VERSION", rb_str_new2("0.0.5"));
+
+  /* send flags */
+
+  /* Message is unordered */
+  rb_define_const(cSocket, "SCTP_UNORDERED", INT2NUM(SCTP_UNORDERED));
+
+  /* Override the primary address */
+  rb_define_const(cSocket, "SCTP_ADDR_OVER", INT2NUM(SCTP_ADDR_OVER));
+
+  /* Send an ABORT to peer */
+  rb_define_const(cSocket, "SCTP_ABORT", INT2NUM(SCTP_ABORT));
+
+  /* Start a shutdown procedure */
+  rb_define_const(cSocket, "SCTP_EOF", INT2NUM(SCTP_EOF));
+
+  /* Send to all associations */
+  rb_define_const(cSocket, "SCTP_SENDALL", INT2NUM(SCTP_SENDALL));
+
+  rb_define_const(cSocket, "MSG_NOTIFICATION", INT2NUM(MSG_NOTIFICATION));
+
+  // ASSOCIATION STATES //
+
+  rb_define_const(cSocket, "SCTP_EMPTY", INT2NUM(SCTP_EMPTY));
+  rb_define_const(cSocket, "SCTP_CLOSED", INT2NUM(SCTP_CLOSED));
+  rb_define_const(cSocket, "SCTP_COOKIE_WAIT", INT2NUM(SCTP_COOKIE_WAIT));
+  rb_define_const(cSocket, "SCTP_COOKIE_ECHOED", INT2NUM(SCTP_COOKIE_ECHOED));
+  rb_define_const(cSocket, "SCTP_ESTABLISHED", INT2NUM(SCTP_ESTABLISHED));
+  rb_define_const(cSocket, "SCTP_SHUTDOWN_PENDING", INT2NUM(SCTP_SHUTDOWN_PENDING));
+  rb_define_const(cSocket, "SCTP_SHUTDOWN_SENT", INT2NUM(SCTP_SHUTDOWN_SENT));
+  rb_define_const(cSocket, "SCTP_SHUTDOWN_RECEIVED", INT2NUM(SCTP_SHUTDOWN_RECEIVED));
+  rb_define_const(cSocket, "SCTP_SHUTDOWN_ACK_SENT", INT2NUM(SCTP_SHUTDOWN_ACK_SENT));
 }

data/sctp-socket.gemspec

@@ -1,11 +1,10 @@
 Gem::Specification.new do |spec|
   spec.name        = 'sctp-socket'
-  spec.version     = '0.0.1'
+  spec.version     = '0.0.5'
   spec.author      = 'Daniel Berger'
   spec.email       = 'djberg96@gmail.com'
   spec.summary     = 'Ruby bindings for SCTP sockets'
-  spec.description = 'Ruby bindings for SCTP sockets'
-  spec.homepage    = 'https://github.com/djberg96/sctp-sockets'
+  spec.homepage    = 'https://github.com/djberg96/sctp-socket'
   spec.license     = 'Apache-2.0'
   spec.cert_chain  = ['certs/djberg96_pub.pem']
 
@@ -15,8 +14,14 @@ Gem::Specification.new do |spec|
 
   spec.extensions = ['ext/sctp/extconf.rb']
 
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rake-compiler'
-  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'bundler', '~> 2.1'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rake-compiler', '~> 1.1'
+  spec.add_development_dependency 'rspec', '~> 3.9'
+
+  spec.description = <<-EOF
+    The sctp-socket library provides Ruby bindings for SCTP sockets. is a
+    message oriented, reliable transport protocol with direct support for
+    multihoming.
+  EOF
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sctp-socket
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.5
 platform: ruby
 authors:
 - Daniel Berger
@@ -35,65 +35,68 @@ cert_chain:
   ORVCZpRuCPpmC8qmqxUnARDArzucjaclkxjLWvCVHeFa9UP7K3Nl9oTjJNv+7/jM
   WZs4eecIcUc4tKdHxcAJ0MO/Dkqq7hGaiHpwKY76wQ1+8xAh
   -----END CERTIFICATE-----
-date: 2020-11-24 00:00:00.000000000 Z
+date: 2021-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: Ruby bindings for SCTP sockets
+        version: '3.9'
+description: |2
+      The sctp-socket library provides Ruby bindings for SCTP sockets. is a
+      message oriented, reliable transport protocol with direct support for
+      multihoming.
 email: djberg96@gmail.com
 executables: []
 extensions:
@@ -116,7 +119,7 @@ files:
 - ext/sctp/socket/client.c
 - ext/sctp/socket/server.c
 - sctp-socket.gemspec
-homepage: https://github.com/djberg96/sctp-sockets
+homepage: https://github.com/djberg96/sctp-socket
 licenses:
 - Apache-2.0
 metadata: {}
@@ -135,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.2.25
 signing_key: 
 specification_version: 4
 summary: Ruby bindings for SCTP sockets