sctp-socket 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30d42e64586703d527155f2fb7582e165ce6662fa3ddecec417b9905479454ca
-  data.tar.gz: ad2fce717f7d4c42a83db6524e7323c92b1b1edf1b73058757e6689a638cc3ce
+  metadata.gz: 6a4c2e587ffc98a2c81d1d2a267fa4936539dc2456a9106a0146f31275e6db21
+  data.tar.gz: e5aa191fd3beb57240128ef58ef82df8f3b6beba3c25a5b357bc9b5effc7c238
 SHA512:
-  metadata.gz: 94b319f18b44be59f7b5434ccbd9c4e2b4b1e948d9dfcf155c29c497e13059a6016a945aca04712b0b1afaa6801043450268533c758491ce118dc615d1209c4b
-  data.tar.gz: f77fd5430cc646354117a27c3a5a2064b8af11cdc7019c7400286300065eea6b107b6b7bb7796408de0f5998661c652eb16b07460b54ef25defca5a231ffa731
+  metadata.gz: d023d5c17b03912812d02c8cb58279b5c874c45c481bdc1cd685dd89e8f2d62565512675d2cdc89f5e6b8107dce42634a3a1b4a063df8a6b32fed6762029adb4
+  data.tar.gz: 900e6fb83030d63453d99f9046942b2e6dfaee4340615d668669a922abc5628f58056aa464c9f36fe974ac0cccec4f3699fee7211778b6e49f49d856d7ea002d

data/.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+github: djberg96
+open_collective: daniel-berger

data/.gitignore

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

data/CHANGES.md

@@ -1,3 +1,17 @@
+## 0.0.6 - 24-May-2024
+* Fixup the sendv method and add some documentation.
+* Added documentation to the get_status method.
+* Update the example server and client code, including comments for how to
+  setup multiple dummy IP addresses locally for testing.
+* Some warning cleanup and build improvements.
+* Added SCTP_BINDX constants.
+* Started adding some real specs.
+
+## 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.

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

@@ -2,17 +2,19 @@
 
 A Ruby interface for SCTP sockets.
 
-WARNING: THIS IS CURRENTLY AN ALPHA PRODUCT. NOT RECOMMENDED FOR PRODUCTION USE AT THIS TIME.
-
 ## Prerequisites
 
 You will need the sctp development headers installed.
 
-On some systems, such as RHEL8, you may need to enable the sctp module.
+On some systems, such as RHEL8 or later, you may need to enable the sctp module.
 
 ## Installation
 
-  `gem install sctp-socket`
+`gem install sctp-socket`
+
+## Installing the Trusted Cert
+
+`gem cert --add <(curl -Ls https://raw.githubusercontent.com/djberg96/sctp-socket/main/certs/djberg96_pub.pem)`
 
 ## About SCTP
 
@@ -30,7 +32,7 @@ is applied to correct loss or corruption of data.
 
 ## Synopsis
 
-```
+```ruby
 # sample_server.rb
 require 'sctp/socket'
 
@@ -62,17 +64,25 @@ end
 Currently this has only been developed and tested on Linux. Other platforms
 will probably only be supported via community contributions.
 
+The sendv method is not available on some Linux variants. 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
 
 ## Copyright
 
-(C) 2020, Daniel J. Berger
+(C) 2020-2024, Daniel J. Berger
 Al Rights Reserved
 
 ## Author

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/examples/client_example.rb

@@ -1,11 +1,40 @@
 require 'socket'
 require 'sctp/socket'
 
+# Adjust as needed. Server server_example.rb for creating
+# fake network interfaces for testing.
+addresses = ['1.1.1.1', '1.1.1.2']
+
 begin
   port = 62324
   socket = SCTP::Socket.new
-  bytes_sent = socket.sendmsg(:message => "Hello World!", :addresses => ['127.0.0.1'], :port => port, :stream => 2)
-  p bytes_sent
+
+  # Optional, but could bind to a subset of available addresses
+  p socket.bind(:addresses => addresses)
+
+  # Initial connection
+  p socket.connect(:addresses => addresses, :port => port)
+
+  # Try a sendv
+  p socket.sendv(:message => ["Hello ", "World!"])
+
+  # Send messages on separate streams of the same connection
+  arr = []
+
+  0.upto(4) do |n|
+    arr << Thread.new do |t|
+      puts "Stream: #{n}"
+      bytes_sent = socket.sendmsg(
+        :message   => "Hello World: #{n+1}",
+        :addresses => addresses.shuffle,
+        :stream    => n,
+        :port      => port
+      )
+      puts "Bytes Sent: #{bytes_sent}"
+    end
+  end
+
+  arr.map(&:join)
 ensure
   socket.close if socket
 end

data/examples/server_example.rb

@@ -1,11 +1,31 @@
 require 'sctp/socket'
 
+# rake compile + ruby -Ilib to run local version
+puts "VERSION: #{SCTP::Socket::VERSION}"
+
+# To test multiple IP addresses locally:
+#
+# sudo apt install iproute2
+# Add 'dummy' to /etc/modules
+#
+# sudo ip link add dummy1 type dummy
+# sudo ip link add dummy2 type dummy
+#
+# sudo ip addr add 1.1.1.1/24 dev dummy1
+# sudo ip addr add 1.1.1.2/24 dev dummy2
+#
+# sudo ip link set dummy1 up
+# sudo ip link set dummy2 up
+
 # Adjust IP addresses as needed
+addresses = ['1.1.1.1', '1.1.1.2']
+
 begin
   port = 62324
   socket = SCTP::Socket.new
-  socket.bind(:port => port, :addresses => ['10.0.5.5', '10.0.6.5'])
+  socket.bind(:port => port, :addresses => addresses)
   socket.set_initmsg(:output_streams => 5, :input_streams => 5, :max_attempts => 4)
+  socket.subscribe(:data_io => true, :shutdown => true, :send_failure => true, :partial_delivery => true)
   socket.listen
 
   while true

data/ext/sctp/extconf.rb

@@ -1,5 +1,30 @@
 require 'mkmf'
 
-have_header('netinet/sctp.h')
+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"
+  end
+
+  warn msg
+  exit
+end
+
 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

@@ -17,11 +17,27 @@ 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
+#define IOV_MAX INT_MAX
+#endif
+#endif
+
+// TODO: Yes, I know I need to update the signature.
 VALUE convert_sockaddr_in_to_struct(struct sockaddr_in* addr){
-  char ipbuf[16];
+  char ipbuf[INET6_ADDRSTRLEN];
 
-  inet_ntop(addr->sin_family, &(((struct sockaddr_in *)addr)->sin_addr), ipbuf, sizeof(ipbuf));
+  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),
@@ -169,6 +185,8 @@ static VALUE rsctp_bind(int argc, VALUE* argv, VALUE self){
     port = sin.sin_port;
   }
 
+  rb_iv_set(self, "@port", INT2NUM(port));
+
   return INT2NUM(port);
 }
 
@@ -316,6 +334,114 @@ static VALUE rsctp_getlocalnames(VALUE self){
   return v_array;
 }
 
+#ifdef HAVE_SCTP_SENDV
+/*
+ * Transmit a message to an SCTP endpoint using a gather-write. The following
+ * hash of options is permitted:
+ *
+ *  * message   - An array of strings that will be joined into a single message.
+ *  * addresses - An array of IP addresses to setup an association to send the message.
+ *  * info_type - The type of information provided. The default is SCTP_SENDV_SNDINFO.
+ *
+ *  Example:
+ *
+ *    socket = SCTP::Socket.new
+ *
+ *    socket.sendv
+ *      :message   => ['Hello ', 'World.'],
+ *      :addresses => ['10.0.5.4', '10.0.6.4'],
+ *      :info_type => SCTP::Socket:::SCTP_SENDV_SNDINFO
+ *    )
+ *
+ *  CAVEAT: Currently addresses does not work, and info_type is not yet supported.
+ *
+ *  Returns the number of bytes sent.
+ */
+static VALUE rsctp_sendv(VALUE self, VALUE v_options){
+  VALUE v_msg, v_message, v_addresses;
+  struct iovec iov[IOV_MAX];
+  struct sockaddr_in* addrs;
+  struct sctp_sndinfo info;
+  int i, sock_fd, num_bytes, size, num_ip;
+
+  Check_Type(v_options, T_HASH);
+
+  bzero(&iov, sizeof(iov));
+  bzero(&info, sizeof(info));
+
+  v_message   = rb_hash_aref2(v_options, "message");
+  v_addresses = rb_hash_aref2(v_options, "addresses");
+
+  if(!NIL_P(v_message))
+    Check_Type(v_message, T_ARRAY);
+
+  if(!NIL_P(v_addresses)){
+    Check_Type(v_addresses, T_ARRAY);
+    num_ip = RARRAY_LEN(v_addresses);
+    addrs = (struct sockaddr_in*)alloca(sizeof(struct sockaddr_in) * num_ip);
+  }
+  else{
+    addrs = NULL;
+    num_ip = 0;
+  }
+
+  sock_fd = NUM2INT(rb_iv_get(self, "@sock_fd"));
+  size = RARRAY_LEN(v_message);
+
+  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");
+
+  info.snd_flags = SCTP_UNORDERED;
+  info.snd_assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
+
+  if(!NIL_P(v_addresses)){
+    int i, port;
+    VALUE v_address, v_port;
+
+    v_port = NUM2INT(rb_iv_get(self, "@port"));
+
+    if(NIL_P(v_port))
+      port = 0;
+    else
+      port = NUM2INT(v_port);
+
+    for(i = 0; i < num_ip; i++){
+      v_address = RARRAY_PTR(v_addresses)[i];
+      addrs->sin_family = NUM2INT(rb_iv_get(self, "@domain"));
+      addrs->sin_port = htons(port);
+      addrs->sin_addr.s_addr = inet_addr(StringValueCStr(v_address));
+      addrs += sizeof(struct sockaddr_in);
+    }
+  }
+
+  for(i = 0; i < size; i++){
+    v_msg = RARRAY_PTR(v_message)[i];
+    iov[i].iov_base = StringValueCStr(v_msg);
+    iov[i].iov_len = RSTRING_LEN(v_msg);
+  }
+
+  num_bytes = sctp_sendv(
+    sock_fd,
+    iov,
+    size,
+    (struct sockaddr*)addrs,
+    num_ip,
+    &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.
  *
@@ -413,14 +539,14 @@ static VALUE rsctp_send(VALUE self, VALUE v_options){
  * Transmit a message to an SCTP endpoint. The following hash of options
  * is permitted:
  *
- *  :message -> The message to send to the endpoint. Mandatory.
- *  :stream  -> The SCTP stream number you wish to send the message on.
- *  :to      -> An array of addresses to send the message to.
- *  :context -> The default context used for the sendmsg call if the send fails.
- *  :ppid    -> The payload protocol identifier that is passed to the peer endpoint. 
- *  :flags   -> A bitwise integer that contain one or more values that control behavior.
+ *  :message   -> The message to send to the endpoint. Mandatory.
+ *  :stream    -> The SCTP stream number you wish to send the message on.
+ *  :addresses -> An array of addresses to send the message to.
+ *  :context   -> The default context used for the sendmsg call if the send fails.
+ *  :ppid      -> The payload protocol identifier that is passed to the peer endpoint. 
+ *  :flags     -> A bitwise integer that contain one or more values that control behavior.
  *
- *  Note that the :to option is not mandatory in a one-to-one (SOCK_STREAM)
+ *  Note that the :addresses option is not mandatory in a one-to-one (SOCK_STREAM)
  *  socket connection. However, it must have been set previously via the
  *  connect method.
  *
@@ -429,12 +555,14 @@ static VALUE rsctp_send(VALUE self, VALUE v_options){
  *    socket = SCTP::Socket.new
  *
  *    socket.sendmsg(
- *      :message => "Hello World!",
- *      :stream  => 3,
- *      :flags   => SCTP::Socket::SCTP_UNORDERED | SCTP::Socket::SCTP_SENDALL,
- *      :ttl     => 100,
- *      :to      => ['10.0.5.4', '10.0.6.4']
+ *      :message   => "Hello World!",
+ *      :stream    => 3,
+ *      :flags     => SCTP::Socket::SCTP_UNORDERED | SCTP::Socket::SCTP_SENDALL,
+ *      :ttl       => 100,
+ *      :addresses => ['10.0.5.4', '10.0.6.4']
  *    )
+ *
+ *  Returns the number of bytes sent.
  */
 static VALUE rsctp_sendmsg(VALUE self, VALUE v_options){
   VALUE v_msg, v_ppid, v_flags, v_stream, v_ttl, v_context, v_addresses;
@@ -566,7 +694,10 @@ static VALUE rsctp_recvmsg(int argc, VALUE* argv, VALUE self){
 
   sock_fd = NUM2INT(rb_iv_get(self, "@sock_fd"));
   length = sizeof(struct sockaddr_in);
+
   bzero(buffer, sizeof(buffer));
+  bzero(&clientaddr, sizeof(clientaddr));
+  bzero(&sndrcvinfo, sizeof(sndrcvinfo));
 
   bytes = sctp_recvmsg(
     sock_fd,
@@ -678,6 +809,7 @@ static VALUE rsctp_recvmsg(int argc, VALUE* argv, VALUE self){
           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);
 
@@ -700,6 +832,24 @@ static VALUE rsctp_recvmsg(int argc, VALUE* argv, VALUE self){
           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),
@@ -822,7 +972,7 @@ static VALUE rsctp_set_initmsg(VALUE self, VALUE v_options){
  *   - The peer has sent a shutdown to the local endpoint.
  *
  *   :data_io
- *   - Message data was received. On by default.
+ *   - Message data was received. You will want to subscribe to this in most cases.
  *
  *   Others:
  *
@@ -835,14 +985,12 @@ static VALUE rsctp_set_initmsg(VALUE self, VALUE v_options){
  *   :sender_dry
  *   :peer_error
  *
- * By default only data_io is subscribed to.
- *
  * Example:
  * 
  *   socket = SCTP::Socket.new
  *
  *   socket.bind(:port => port, :addresses => ['127.0.0.1'])
- *   socket.subscribe(:shutdown => true, :send_failure => true)
+ *   socket.subscribe(:data_io => true, :shutdown => true, :send_failure => true)
  */
 static VALUE rsctp_subscribe(VALUE self, VALUE v_options){
   int sock_fd;
@@ -860,9 +1008,12 @@ static VALUE rsctp_subscribe(VALUE self, VALUE v_options){
   if(RTEST(rb_hash_aref2(v_options, "address")))
     events.sctp_address_event = 1;
 
-  // Use the new version
   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;
@@ -916,7 +1067,7 @@ static VALUE rsctp_listen(int argc, VALUE* argv, VALUE self){
   sock_fd = NUM2INT(rb_iv_get(self, "@sock_fd"));
 
   if(listen(sock_fd, backlog) < 0)
-    rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
+    rb_raise(rb_eSystemCallError, "listen: %s", strerror(errno));
   
   return self;
 }
@@ -942,6 +1093,61 @@ 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;
@@ -964,7 +1170,95 @@ static VALUE rsctp_shutdown(int argc, VALUE* argv, VALUE self){
   return self;
 }
 
-void Init_socket(){
+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)
+  );
+}
+
+/*
+ * Get the status of a connected socket.
+ *
+ * Example:
+ *
+ *   socket = SCTP::Socket.new
+ *   socket.connect(...)
+ *   socket.get_status
+ *
+ * Returns a Struct::Status object, which contains the following fields:
+ *
+ *  * association_id
+ *  * state
+ *  * receive_window
+ *  * unacknowledged_data
+ *  * pending_data
+ *  * inbound_streams
+ *  * outbound_streams
+ *  * fragmentation_point
+ *  * primary (IP)
+ */
+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(void){
   mSCTP   = rb_define_module("SCTP");
   cSocket = rb_define_class_under(mSCTP, "Socket", rb_cObject);
 
@@ -1016,6 +1310,26 @@ void Init_socket(){
     "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);
 
   rb_define_method(cSocket, "bind", rsctp_bind, -1);
@@ -1023,10 +1337,19 @@ 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);
@@ -1038,8 +1361,8 @@ void Init_socket(){
   rb_define_attr(cSocket, "association_id", 1, 1);
   rb_define_attr(cSocket, "port", 1, 1);
 
-  /* 0.0.4: The version of this library */
-  rb_define_const(cSocket, "VERSION", rb_str_new2("0.0.4"));
+  /* 0.0.6: The version of this library */
+  rb_define_const(cSocket, "VERSION", rb_str_new2("0.0.6"));
 
   /* send flags */
 
@@ -1059,4 +1382,21 @@ void Init_socket(){
   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));
+
+  // BINDING //
+
+  rb_define_const(cSocket, "SCTP_BINDX_ADD_ADDR", INT2NUM(SCTP_BINDX_ADD_ADDR));
+  rb_define_const(cSocket, "SCTP_BINDX_REM_ADDR", INT2NUM(SCTP_BINDX_REM_ADDR));
 }

data/sctp-socket.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name        = 'sctp-socket'
-  spec.version     = '0.0.4'
+  spec.version     = '0.0.6'
   spec.author      = 'Daniel Berger'
   spec.email       = 'djberg96@gmail.com'
   spec.summary     = 'Ruby bindings for SCTP sockets'
@@ -19,6 +19,16 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake-compiler', '~> 1.1'
   spec.add_development_dependency 'rspec', '~> 3.9'
 
+  spec.metadata = {
+    'homepage_uri'          => 'https://github.com/djberg96/sctp-socket',
+    'bug_tracker_uri'       => 'https://github.com/djberg96/sctp-socket/issues',
+    'changelog_uri'         => 'https://github.com/djberg96/sctp-socket/blob/main/CHANGES.md',
+    'documentation_uri'     => 'https://github.com/djberg96/sctp-socket/wiki',
+    'source_code_uri'       => 'https://github.com/djberg96/sctp-socket',
+    'wiki_uri'              => 'https://github.com/djberg96/sctp-socket/wiki',
+    'rubygems_mfa_required' => 'true'
+  }
+
   spec.description = <<-EOF
     The sctp-socket library provides Ruby bindings for SCTP sockets. is a
     message oriented, reliable transport protocol with direct support for

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sctp-socket
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
 platform: ruby
 authors:
 - Daniel Berger
@@ -35,7 +35,7 @@ cert_chain:
   ORVCZpRuCPpmC8qmqxUnARDArzucjaclkxjLWvCVHeFa9UP7K3Nl9oTjJNv+7/jM
   WZs4eecIcUc4tKdHxcAJ0MO/Dkqq7hGaiHpwKY76wQ1+8xAh
   -----END CERTIFICATE-----
-date: 2020-12-03 00:00:00.000000000 Z
+date: 2024-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -103,6 +103,7 @@ extensions:
 - ext/sctp/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/FUNDING.yml"
 - ".gitignore"
 - CHANGES.md
 - Gemfile
@@ -122,7 +123,14 @@ files:
 homepage: https://github.com/djberg96/sctp-socket
 licenses:
 - Apache-2.0
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/djberg96/sctp-socket
+  bug_tracker_uri: https://github.com/djberg96/sctp-socket/issues
+  changelog_uri: https://github.com/djberg96/sctp-socket/blob/main/CHANGES.md
+  documentation_uri: https://github.com/djberg96/sctp-socket/wiki
+  source_code_uri: https://github.com/djberg96/sctp-socket
+  wiki_uri: https://github.com/djberg96/sctp-socket/wiki
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -138,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
 summary: Ruby bindings for SCTP sockets