sctp-socket 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a53fb8e5953dbf9ca5c45e273ab45d4982ade9ec4b77e44657cd826757fb8ef
-  data.tar.gz: 8d3aa7a1087c0f348cf25d8dde354fcb5bfba61b7a9c6db78cf60922496bf983
+  metadata.gz: fd42fc7e43b41e85d64c8a82f258add07ead601ff3f12bac22bf818e9ecb0162
+  data.tar.gz: bb950e7a673d6aeee90fed9435e0162d02b09e29df5a8abe35451fcc6823dddd
 SHA512:
-  metadata.gz: 8e23832cbb9cc0b8741ef696ed97aa494c17a12cc22bbf2b6eeaaab401cd654efb9b9966913557d2d442ae694e698c081c147d6b448d88876efecc831254c0d7
-  data.tar.gz: 17617bb21948741bc3397c9528bf283c5a07ec6bc06b57f7db17b925236025738cbe72390d7cb9ceb791d4b992ecba438d0a5ef3752baffc1d3b676fff5c719c
+  metadata.gz: dab10bca673f2330c376686c53b6b5de62089be1b127252cf8ba8c5b46af2c7e1a409995b5b054bbf53702d47dc6c7b7b57660a624edbefeec566b8dff9aaaad
+  data.tar.gz: 28e75fa2e02f5388736d8515ace3497bfc7e907ffa0bae5131d14f89374c2045d800603a5a126e84bc5a2b2e36145a9887e0838b6c82aa1f869cea7463aa511b

data/.github/workflows/ruby.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['3.2', '3.3']
+        ruby-version: ['3.2', '3.3', '3.4']
     steps:
     - uses: actions/checkout@v4
     - name: Install SCTP headers

data/.gitignore

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

data/CHANGES.md

@@ -1,3 +1,15 @@
+## 0.2.0 - 3-Aug-2025
+* Added an SCTP::Server class, generally modelled on the TCPServer class.
+* Added the map_ipv4? method to query IPv4 mapping status.
+* Added the auth_support? method to query authentication support status.
+* Fixed critical segmentation fault in sendmsg method with improved parameter validation.
+* Fixed potential segmentation fault in sendv method with better error handling.
+* Added comprehensive test coverage for many more methods.
+* Enhanced parameter validation across multiple methods to prevent crashes.
+* Improved documentation and fixed syntax errors in method examples.
+* Internally several methods were switched from sctp_opt_info to setsockopt
+  because the former doesn't always seem to work.
+
 ## 0.1.4 - 1-Feb-2025
 * Added the set_retransmission_info method.
 * Added the get_rto_info and set_rto_info aliases.

data/README.md

@@ -55,6 +55,81 @@ ensure
 end
 ```
 
+## Using SCTP::Server
+
+The `SCTP::Server` class provides a TCPServer-like interface for SCTP sockets,
+making it easier to create SCTP server applications.
+
+### One-to-Many Mode (Default)
+
+In one-to-many mode, a single server socket handles multiple client associations:
+
+```ruby
+require 'sctp/socket'
+
+# Create server listening on multiple addresses
+server = SCTP::Server.new(['127.0.0.1', '192.168.1.100'], 9999)
+
+puts "Server listening on #{server.addr.join(', ')}:#{server.local_port}"
+
+loop do
+  # Receive data from any client association
+  data, info = server.recvmsg
+  puts "Received from association #{info.association_id}: #{data}"
+
+  # Echo back to the same association
+  server.sendmsg("Echo: #{data}", association_id: info.association_id)
+end
+```
+
+### One-to-One Mode
+
+In one-to-one mode, the server creates individual sockets for each association:
+
+```ruby
+require 'sctp/socket'
+
+# Create server in one-to-one mode
+server = SCTP::Server.new(['127.0.0.1'], 9999, one_to_one: true)
+
+loop do
+  # Accept a new client connection
+  client = server.accept
+
+  # Handle client in a thread
+  Thread.new(client) do |c|
+    # Get the initial message that established the connection
+    data, info = c.initial_message
+    puts "New client: #{data}"
+
+    # Continue receiving from this specific client
+    loop do
+      data, info = c.recvmsg
+      c.sendmsg("Echo: #{data}")
+    end
+  rescue => e
+    puts "Client error: #{e.message}"
+  ensure
+    c.close
+  end
+end
+```
+
+### Server Options
+
+```ruby
+# Create server with additional options
+server = SCTP::Server.new(
+  ['127.0.0.1'],
+  9999,
+  one_to_one: false,
+  backlog: 256,
+  autoclose: 30,
+  init_msg: { output_streams: 10, input_streams: 10 },
+  subscriptions: { data_io: true, association: true }
+)
+```
+
 ## Future Plans
 
 * Add more specs.

data/examples/client_for_server_test.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'sctp/socket'
+
+# Simple SCTP client to test with the server
+
+puts "SCTP Client Example"
+puts "==================="
+
+begin
+  # Connect to the server
+  client = SCTP::Socket.new
+  client.connectx(addresses: ['127.0.0.1'], port: 9999)
+
+  puts "Connected to server at 127.0.0.1:9999"
+
+  # Send a few test messages
+  ["Hello, SCTP!", "How are you?", "Goodbye!"].each_with_index do |message, i|
+    puts "Sending: #{message}"
+    client.sendmsg(message: message, stream: i % 3)  # Use different streams
+
+    # Receive the echo
+    data, info = client.recvmsg
+    puts "Received: #{data.inspect} on stream #{info.stream}"
+
+    sleep 1
+  end
+
+rescue => e
+  puts "Error: #{e.message}"
+ensure
+  client.close if client
+  puts "Client closed"
+end

data/examples/sctp_server_example.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+# Example SCTP server using the SCTP::Server class
+# Run with: ruby -I lib examples/sctp_server_example.rb
+
+require 'sctp/socket'
+
+puts "SCTP::Server Example"
+puts "==================="
+
+# Example 1: One-to-many server (default mode)
+puts "\n1. One-to-many server example:"
+puts "   Multiple clients can connect to the same server socket"
+puts "   All communication happens through the main server socket"
+
+server = SCTP::Server.new(['127.0.0.1'], 9999)
+puts "   Server listening on: #{server}"
+
+# Simulate server operation (normally you'd have a loop here)
+puts "   Server ready to receive messages with server.recvmsg"
+puts "   Send messages back with server.sendmsg(data, association_id: id)"
+
+server.close
+puts "   Server closed"
+
+# Example 2: One-to-one server with peeloff
+puts "\n2. One-to-one server example:"
+puts "   Each client connection gets its own dedicated socket"
+puts "   Uses peeloff() to create individual sockets per association"
+
+server_1to1 = SCTP::Server.new(['127.0.0.1'], 9998, one_to_one: true)
+puts "   Server listening on: #{server_1to1}"
+
+# Simulate server operation
+puts "   Server ready to accept connections with server.accept"
+puts "   Each accepted connection returns a new SCTP::Socket"
+puts "   Handle each client in a separate thread"
+
+server_1to1.close
+puts "   Server closed"
+
+# Example 3: Server with multiple addresses (multihoming)
+puts "\n3. Multihomed server example:"
+puts "   SCTP supports binding to multiple IP addresses"
+
+begin
+  # This will work if you have multiple addresses configured
+  multi_server = SCTP::Server.new(['127.0.0.1', '127.0.0.2'], 9997)
+  puts "   Multihomed server: #{multi_server}"
+  multi_server.close
+rescue => e
+  puts "   Multihomed server failed (expected if addresses not configured): #{e.message}"
+end
+
+# Example 4: Server with custom options
+puts "\n4. Server with custom options:"
+
+custom_server = SCTP::Server.new(['127.0.0.1'], 9996,
+  backlog: 64,
+  autoclose: 10,
+  init_msg: { output_streams: 10, input_streams: 10 }
+)
+puts "   Custom server: #{custom_server}"
+custom_server.close
+
+puts "\nExample complete!"
+puts "\nTo test with a real client:"
+puts "1. Start the server in one terminal"
+puts "2. Use examples/client_example.rb to connect"
+puts "3. Or create a simple client with SCTP::Socket.new and connectx()"

data/examples/server_using_sctp_server.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require 'sctp/socket'
+
+# Simple SCTP echo server example using SCTP::Server
+
+puts "SCTP Echo Server Example"
+puts "========================"
+
+# Create a server that binds to localhost on port 9999
+server = SCTP::Server.new(['127.0.0.1'], 9999)
+
+puts "Server listening on #{server.addr.join(', ')}:#{server.local_port}"
+puts "Mode: #{server.one_to_one ? 'one-to-one' : 'one-to-many'}"
+puts "Press Ctrl+C to stop"
+
+begin
+  if server.one_to_one
+    # One-to-one mode: accept individual connections
+    puts "Waiting for connections..."
+    loop do
+      client = server.accept
+      puts "Accepted connection from association #{client.initial_message[1].association_id}"
+
+      # Handle the connection in a thread
+      Thread.new(client) do |c|
+        begin
+          # Get the initial message that triggered the connection
+          data, info = c.initial_message
+          puts "Initial message: #{data.inspect}"
+
+          # Echo it back
+          c.sendmsg("Echo: #{data}")
+
+          # Continue receiving messages
+          loop do
+            data, info = c.recvmsg
+            puts "Received: #{data.inspect}"
+            c.sendmsg("Echo: #{data}")
+          end
+        rescue => e
+          puts "Client connection error: #{e.message}"
+        ensure
+          c.close
+          puts "Client disconnected"
+        end
+      end
+    end
+  else
+    # One-to-many mode: handle all connections on the same socket
+    puts "Waiting for messages..."
+    loop do
+      data, info = server.recvmsg
+      puts "Received from association #{info.association_id}: #{data.inspect}"
+
+      # Echo the message back to the sender
+      server.sendmsg("Echo: #{data}", association_id: info.association_id)
+    end
+  end
+rescue Interrupt
+  puts "\nShutting down server..."
+ensure
+  server.close
+  puts "Server closed"
+end