sping 1.0.2 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5ab53904c197ff35bab0d5fc29f26b5ada7c1ded24548b30d42df12d3df6837
-  data.tar.gz: 8bd57a7d33c5f39f1eb76ad2551550fafecc5836f373b3c3675648e620afebe1
+  metadata.gz: 9f7679b3fb31d07d034182114e576f3e272ef8223954f592bb30a98378b98fd5
+  data.tar.gz: b8d21d6a58ffb3c57481cc421d61f8fc25da32646fb8d5ae160829017d01fb14
 SHA512:
-  metadata.gz: 90e021acc0d54dace745238c35566efacdd5be77d8db2f9ecd6e6aa1ed8d71ee89c552fb4674be23e1adcf244987154e1975364731eff78e76ad5dd7006ec3df
-  data.tar.gz: 336910fef1e87548f060a4a70547b272d78362828274dd5b21ed011a821a66ed71c7ece447045ca717a169676fa872594cbbd9e649e701731c63cd812c7f7bba
+  metadata.gz: a6a2c6897ead8f7371b2f1a83719c1a8f2c07d44957a9c302bc548855d25671858435fe0d6e8162e14737e065f6bbcede37defd2ea21e23561d19e7f8d5ef63f
+  data.tar.gz: 2618e70abea52acc38364f7fb431dafa12a4d48ad8f07665f93ac76e316784e6a2f8f5d2b463a55053da88b10f46dc23adf16846abb1a4b1d4677eb9eef09e7f

data/bin/sping

@@ -7,10 +7,10 @@ require 'msgpack'
 require_relative '../lib/session_manager'
 
 MessagePack::DefaultFactory.register_type(
-    MessagePack::Timestamp::TYPE,
-    Time,
-    packer: MessagePack::Time::Packer,
-    unpacker: MessagePack::Time::Unpacker
+  MessagePack::Timestamp::TYPE,
+  Time,
+  packer: MessagePack::Time::Packer,
+  unpacker: MessagePack::Time::Unpacker
 )
 
 $logger = Logger.new $stdout
@@ -21,18 +21,18 @@ sess_mgr.run
 sess_mgr.run_server
 
 ARGV.each do |host|
-    sess_mgr.new_session(host)
+  sess_mgr.new_session(host)
 end
 
 Signal.trap('INT') do
-    puts "Stop server..."
-    sess_mgr.stop_server
+  puts 'Stop server...'
+  sess_mgr.stop_server
 
-    puts "Stop sessions..."
-    sess_mgr.stop_sessions
+  puts 'Stop sessions...'
+  sess_mgr.stop_sessions
 
-    puts "Stop client..."
-    sess_mgr.stop
+  puts 'Stop client...'
+  sess_mgr.stop
 end
 
 sess_mgr.join

data/lib/errors.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# sharable_constant_value: literal
+
+module SPing
+  class SPingError < StandardError; end
+
+  class SessionManagerError < SPingError; end
+  class OutOfSessions < SessionManagerError; end
+
+  class SessionError < SPingError; end
+  class TCPHandshakeError < SessionError; end
+
+  class PeerError < SPingError; end
+  class InvalidPacketError < PeerError; end
+  class InvalidMessageError < InvalidPacketError; end
+  class UnknownPacketError < InvalidPacketError; end
+  class SignalizedError < PeerError; end
+  class UnknownVersionError < PeerError; end
+  class UnknownSessionError < PeerError; end
+end

data/lib/last_acks.rb

@@ -1,21 +1,36 @@
 # frozen_string_literal: true
 # sharable_constant_value: literal
 
-class LastAcks
-
-    attr_reader :acks, :size
+module SPing
+  class LastAcks
+    attr_reader :size
 
     def initialize(size = 32)
-        @size = 32
-        @acks = []
+      @size = size
+      @acks = []
+      @acks_mutex = Mutex.new
+
+      @size.times do |index|
+        @acks[index] = {
+          'R' => 0,
+          'U' => Time.at(0),
+          'X' => Time.at(0)
+        }
+      end
+    end
+
+    def acks
+      @acks_mutex.synchronize do
+        return @acks.dup
+      end
     end
 
     def add_ack(ack)
+      @acks_mutex.synchronize do
         @acks << ack
 
-        if @acks.length > @size
-            @acks.shift
-        end
+        @acks.shift if @acks.length > @size
+      end
     end
-
+  end
 end

data/lib/session.rb

@@ -2,228 +2,242 @@
 # sharable_constant_value: literal
 
 module SPing
+  require_relative 'errors'
 
-    class SessionError < StandardError; end
-    class TCPHandshakeError < SessionError; end
+  class Session
+    attr_reader :created, :last_rx, :madebyme
+    attr_accessor :session_id, :tcp_handshake_complete, :udp_handshake_complete
 
-    class Session
+    require 'socket'
+    require 'timeout'
+    require 'msgpack'
+    require_relative 'last_acks'
 
-        attr_reader :created, :last_rx, :madebyme
-        attr_accessor :session_id, :tcp_handshake_complete, :udp_handshake_complete
+    def initialize(host, port, socket, madebyme)
+      @host = host
+      @port = port
+      @socket = socket
+      @created = Time.now
+      @madebyme = madebyme
 
-        require 'socket'
-        require 'timeout'
-        require 'msgpack'
-        require_relative 'last_acks'
+      @tcp_handshake_complete = false
+      @udp_handshake_complete = false
 
-        def initialize(host, port, socket, madebyme)
-            @host = host
-            @port = port
-            @socket = socket
-            @created = Time.now
-            @madebyme = madebyme
+      @last_acks = SPing::LastAcks.new
+    end
 
-            @tcp_handshake_complete = false
-            @udp_handshake_complete = false
+    def do_tcp_handshake1(socket, session_id)
+      socket.write "sping-0.3-https://codeberg.org/mark22k/sping\r\n"
+      socket.flush
 
-            @last_acks = LastAcks.new
-        end
+      invite = socket.readpartial 6
 
-        def do_tcp_handshake1(socket, session_id)
-            socket.write "sping-0.3-https://codeberg.org/mark22k/sping\r\n"
-            socket.flush
+      raise TCPHandshakeError, 'Peer didn\'t invite us.' unless invite.chomp == 'INVITE'
 
-            invite = socket.readpartial 6
+      @session_id = session_id
 
-            if invite.chomp != "INVITE"
-                raise TCPHandshakeError, 'Peer didn\'t invite us.'
-            end
+      socket.write "#{session_id}\r\n"
+      socket.flush
 
-            @session_id = session_id
+      socket.close
 
-            socket.write "#{session_id}\r\n"
-            socket.flush
+      @tcp_handshake_complete = true
+    end
 
-            socket.close
+    def do_tcp_handshake2
+      socket = TCPSocket.new @host, @port
+      banner = socket.readpartial 9001
+      if banner.length > 9000
+        socket.close
+        raise TCPHandshakeError, 'Host banner too big'
+      end
 
-            @tcp_handshake_complete = true
-        end
+      unless banner.start_with? 'sping-0.3-'
+        socket.close
+        raise TCPHandshakeError, 'Host banner not sping'
+      end
 
-        def do_tcp_handshake2
-            socket = TCPSocket.new @host, @port
-            banner = socket.readpartial 9001
-            if banner.length > 9000
-                socket.close
-                raise TCPHandshakeError, 'Host banner too big'
-            end
+      @remote_version = banner.chomp
+      $logger.info "Peer uses the following program version: #{@remote_version.dump}"
 
-            if ! banner.start_with? 'sping-0.3-'
-                socket.close
-                raise TCPHandshakeError, 'Host banner not sping'
-            end
+      socket.write "INVITE\r\n"
+      socket.flush
 
-            @remote_version = banner.chomp
-            $logger.info "Peer uses the following program version: #{@remote_version.dump}"
+      invite_buf = socket.readpartial 32
+      if invite_buf.length > 31 || invite_buf.empty?
+        socket.close
+        raise TCPHandshakeError, 'Invite banner wrong size'
+      end
 
-            socket.write "INVITE\r\n"
-            socket.flush
+      @session_id = invite_buf.chomp.to_i
 
-            inviteBuf = socket.readpartial 32
-            if inviteBuf.length > 31 || inviteBuf.length.zero?
-                socket.close
-                raise TCPHandshakeError, 'Invite banner wrong size'
-            end
+      socket.close
 
-            @session_id = inviteBuf.chomp.to_i
+      @tcp_handshake_complete = true
+    end
 
-            socket.close
+    def set_endpoint(host, port)
+      @host = host
+      @port = port
+    end
 
-            @tcp_handshake_complete = true
-        end
+    def start_udp_handshake_sender(send_interval = 5)
+      raise 'UDP handshake sender is already running.' if @udp_handshake_sender
 
-        def set_endpoint(host, port)
-            @host = host
-            @port = port
+      @udp_handshake_sender = Thread.new(send_interval) do |th_send_interval|
+        loop do
+          send_udp_handshake
+          sleep th_send_interval
         end
+      end
+    end
 
-        def start_udp_handshake_sender(send_interval = 5)
-            raise 'UDP handshake sender is already running.' if @udp_handshake_sender
+    def send_udp_handshake
+      packet = {
+        'Y' => 'h'.ord,
+        'M' => 11_181,
+        'V' => 3,
+        'S' => @session_id
+      }.to_msgpack
 
-            @udp_handshake_sender = Thread.new(send_interval) do |send_interval|
-                loop do
-                    self.send_udp_handshake
-                    sleep send_interval
-                end
-            end
-        end
+      $logger.debug "Send UDP handshake to #{@host} port #{@port}."
+      @socket.send packet, 0, @host, @port
+    end
 
-        def send_udp_handshake
-            packet = {
-                'Y' => 'h'.ord,
-                'M' => 11181,
-                'V' => 3,
-                'S' => @session_id
-            }.to_msgpack
+    def stop_udp_handshake_sender
+      raise 'UDP handshake sender is not running and therefore cannot be terminated.' unless @udp_handshake_sender
 
-            $logger.debug "Send UDP handshake to #{@host} port #{@port}."
-            @socket.send packet, 0, @host, @port
-        end
+      @udp_handshake_sender.kill
+      @udp_handshake_sender = nil
+    end
 
-        def stop_udp_handshake_sender
-            raise 'UDP handshake sender is not running and therefore cannot be terminated.' unless @udp_handshake_sender
-            @udp_handshake_sender.kill
-            @udp_handshake_sender = nil
-        end
+    def udp_handshake_recived
+      stop_udp_handshake_sender if @madebyme
+      @udp_handshake_complete = true
+    end
 
-        def udp_handshake_recived
-            stop_udp_handshake_sender if @madebyme
-            @udp_handshake_complete = true
+    def start_pinger
+      raise 'Pinger is already running.' if @pinger
+
+      @pinger = Thread.new do
+        loop do
+          ping
+          sleep 1
         end
+      end
+    end
 
-        def start_pinger
-            raise 'Pinger is already running.' if @pinger
+    def stop_pinger
+      raise 'Pinger sender is not running and therefore cannot be terminated.' unless @pinger
 
-            @pinger = Thread.new do
-                loop do
-                    self.ping
-                    sleep 1
-                end
-            end
-        end
+      @pinger.kill
+      @pinger = nil
+    end
 
-        def stop_pinger
-            raise 'Pinger sender is not running and therefore cannot be terminated.' unless @pinger
-            @pinger.kill
-            @pinger = nil
-        end
+    def ping
+      current_id = (Time.now.to_i % 255) + 1
+      data = {
+        'Y' => 't'.ord,
+        'M' => 11_181,
+        'S' => @session_id,
+        'I' => current_id,
+        'T' => Time.now,
+        'E' => 0,
+        'A' => @last_acks.acks
+      }.to_msgpack
+
+      $logger.debug "Send ping to #{@host} port #{@port}."
+      @socket.send data, 0, @host, @port
+    end
 
-        def ping
-            current_id = Time.now.to_i % 255 + 1
-            data = {
-                'Y' => 't'.ord,
-                'M' => 11181,
-                'S' => @session_id,
-                'I' => current_id,
-                'T' => Time.now,
-                'E' => 0,
-                'A' => @last_acks.acks
-            }.to_msgpack
-
-            $logger.debug "Send ping to #{@host} port #{@port}."
-            @socket.send data, 0, @host, @port
+    def stop
+      @pinger&.kill
+      @udp_handshake_sender&.kill
+    end
+
+    def handle_ping(packet, rxtime, peeraddr)
+      if !(packet.keys - %w[M Y E I T A S]).empty? ||
+         # M, Y are already checked in handle_packet from session manager
+         !packet['E'].is_a?(Integer) ||
+         !packet['I'].is_a?(Integer) ||
+         !packet['T'].is_a?(Time) ||
+         !packet['A'].is_a?(Array)
+        raise InvalidPacketError, 'The peer has sent an invalid message. The ping packet is incorrectly coded.'
+      end
+
+      raise SignalizedError, "Package displays an error message: #{packet['E']} Processing aborted." if packet['E'] != 0
+
+      id = packet['I']
+      txtime = packet['T']
+      remote_last_acks = packet['A']
+
+      if remote_last_acks.length != 32
+        raise InvalidMessageError, 'The peer has sent an invalid message. It does not contain any 32-Acks.'
+      end
+
+      remote_last_acks.each do |block_ack|
+        if !(block_ack.keys - %w[R U X]).empty? ||
+           !block_ack['R'].is_a?(Integer) ||
+           !block_ack['U'].is_a?(Time) ||
+           !block_ack['X'].is_a?(Time)
+          raise InvalidMessageError, 'The peer has sent an invalid message. An Ack is formatted invalid.'
         end
+      end
+
+      ack = {
+        'R' => id,
+        'U' => txtime,
+        'X' => rxtime
+      }
+
+      @last_acks.add_ack(ack)
+      @last_rx = rxtime
+
+      # This is the A
+      # The peer is B
+      # TX => Time from A to B
+      # RX => Time from B to A
+
+      # Remove zero acks
+      remote_last_acks.reject! { |block_ack| block_ack['R'].zero? }
+
+      # Sort by TX time
+      remote_last_acks.sort_by! { |block_ack| block_ack['U'] }
+
+      newest_remote_ack = remote_last_acks.last.to_h
+
+      # Calculate loss
+      tx_loss = 0
+      rx_loss = 0
+      exchanges = 0
+
+      if remote_last_acks.length == 32
+        # We have enough data
+        exchanges = 32
+        remote_acks = remote_last_acks.map { |ack| ack['R'] }
+        local_acks = @last_acks.acks.map { |ack| ack['R'] }
+
+        tip_id = (Time.now.to_i % 255) + 1
+        starting = tip_id - 32
+
+        last_ids = if tip_id > 32
+                     (starting..tip_id).to_a
+                   else
+                     ((255 + starting)..255).to_a + (1..tip_id).to_a
+                   end
 
-        def stop
-            @pinger&.kill
-            @udp_handshake_sender&.kill
+        last_ids[0...-1].each do |id|
+          tx_loss += 1 unless remote_acks.include? id
         end
 
-        def handle_ping packet, rxtime, peeraddr
-            if packet['E'] != 0
-                $logger.error "Package displays an error message: #{packet['E']} Processing aborted."
-                return
-            end
-
-            id = packet['I']
-            txtime = packet['T']
-            lastAcks = packet['A']
-
-            ack = {
-                'R' => id,
-                'U' => txtime,
-                'X' => rxtime
-            }
-
-            @last_acks.add_ack(ack)
-            @last_rx = rxtime
-
-            # This is the A
-            # The peer is B
-            # TX => Time from A to B
-            # RX => Time from B to A
-
-            # Remove zero acks
-            lastAcks.reject! { |ack| ack['R'] == 0 }
-
-            # Sort by TX time
-            lastAcks.sort_by! { |ack| ack['U'] }
-
-            newest_remote_ack = lastAcks.last.to_h
-
-            # Calculate loss
-            tx_loss = 0
-            rx_loss = 0
-            exchanges = 0
-
-            if lastAcks.length == 32
-                # We have enough data
-                exchanges = 32
-                remote_acks = lastAcks.map { |ack| ack['R'] }
-                local_acks = @last_acks.acks.map { |ack| ack['R'] }
-
-                tip_id = Time.now.to_i % 255 + 1
-                starting = tip_id - 32
-
-                last_ids = nil
-                if tip_id > 32
-                    last_ids = (starting..tip_id).to_a
-                else
-                    last_ids = ((255 + starting)..255).to_a + (1..tip_id).to_a
-                end
-
-                last_ids[0...-1].each do |id|
-                    tx_loss += 1 unless remote_acks.include? id
-                end
-
-                last_ids[1..-1].each do |id|
-                    rx_loss += 1 unless local_acks.include? id
-                end
-            end
-
-            tx_latency = ((newest_remote_ack['X'].to_f - newest_remote_ack['U'].to_f) * 1000.0).round(6)
-            rx_latency = ((rxtime - txtime) * 1000.0).round(6)
-            puts "[#{peeraddr}] RX: #{rx_latency}ms TX: #{tx_latency}ms [Loss RX: #{rx_loss}/#{exchanges} | Loss TX: #{tx_loss}/#{exchanges}]"
+        last_ids[1..].each do |id|
+          rx_loss += 1 unless local_acks.include? id
         end
+      end
 
+      tx_latency = ((newest_remote_ack['X'].to_f - newest_remote_ack['U'].to_f) * 1000.0).round(6)
+      rx_latency = ((rxtime - txtime) * 1000.0).round(6)
+      puts "[#{peeraddr}] RX: #{rx_latency}ms TX: #{tx_latency}ms [Loss RX: #{rx_loss}/#{exchanges} | Loss TX: #{tx_loss}/#{exchanges}]"
     end
+  end
 end

data/lib/session_manager.rb

@@ -2,261 +2,285 @@
 # sharable_constant_value: literal
 
 module SPing
+  require_relative 'errors'
 
-    class SessionManagerError < StandardError; end
-    class OutOfSessions < SessionManagerError; end
+  class SessionManager
+    require 'socket'
+    require 'timeout'
+    require_relative 'session'
 
-    class SessionManager
+    def initialize(host = '::', port = 6924)
+      @host = host
+      @port = port
 
-        require 'socket'
-        require 'timeout'
-        require_relative 'session'
+      @sessions = {}
+      @sessions_mutex = Mutex.new
 
-        def initialize(port = 6924)
-            @port = port
+      @socket = UDPSocket.new(Socket::AF_INET6)
+      @socket.bind @host, @port
+    end
 
-            @sessions = {}
-            @pingers = {}
+    def new_session(host, port = 6924)
+      $logger.info "Add new session for host #{host} port #{port}."
+      session = SPing::Session.new host, port, @socket, true
 
-            @socket = UDPSocket.new(Socket::AF_INET6)
-            @socket.bind "::", @port
-        end
+      counter = 0
+      loop do
+        session_id = request_session session
+        break if session_id
 
-        def new_session(host, port = 6924)
-            $logger.info "Add new session for host #{host} port #{port}."
-            session = SPing::Session.new host, port, @socket, true
-
-            begin
-                counter = 0
-                loop do
-                    begin
-                        session.do_tcp_handshake2
-                    rescue Errno::ECONNRESET, EOFError, IO::TimeoutError, TCPHandshakeError => e
-                        $logger.warn "TCP handshake failed: #{e.message}"
-                        return
-                    end
-                    if ! @sessions.key? session.session_id
-                        break
-                    end
-                    if counter > 5
-                        raise OutOfSessions, 'The peer could not name a session ID that had not yet been assigned.'
-                    end
-                    counter += 1
-                end
-            rescue OutOfSessions => e
-                $logger.error "Out of session: #{e.message}"
-                return
-            end
-
-            $logger.info "TCP handshake for host #{host} port #{port} successful. Session ID is #{session.session_id}."
-
-            $logger.info "Perform UDP handshake for session ID #{session.session_id}."
-            session.start_udp_handshake_sender
-
-            @sessions[session.session_id] = session
+        # rubocop:disable Style/IfUnlessModifier
+        if counter > 5
+          raise OutOfSessions, 'The peer could not name a session ID that had not yet been assigned.'
         end
+        # rubocop:enable Style/IfUnlessModifier
 
-        def del_session(session_id)
-            $logger.debug "Delete session with session id #{session_id}"
+        counter += 1
+      end
 
-            @sessions[session_id].stop
-            @sessions.delete(session_id)
-        end
+      $logger.info "TCP handshake for host #{host} port #{port} successful. Session ID is #{session.session_id}."
 
-        def stop_sessions
-            @sessions.each do |session_id, session|
-                session.stop
-            end
-        end
+      $logger.info "Perform UDP handshake for session ID #{session.session_id}."
+      session.start_udp_handshake_sender
+    rescue Errno::ECONNRESET, EOFError, IO::TimeoutError, TCPHandshakeError => e
+      $logger.warn "TCP handshake failed: #{e.message}"
+    rescue OutOfSessions => e
+      $logger.error "Out of session: #{e.message}"
+    end
 
-        def join
-            @runner&.join
-            @gc_thread&.join
-            @server_thread&.join
-        end
+    def del_session(session_id)
+      $logger.debug "Delete session with session id #{session_id}"
 
-        def run
-            raise 'Client is already running.' if @runner
-            raise 'GC is already running.' if @gc
-
-            @runner = Thread.new do
-                loop do
-                    Thread.new(@socket.recvfrom(10000)) do |buf|
-                        handle_packet buf
-                    end
-                end
-            end
-            @gc_thread = Thread.new do
-                loop do
-                    do_gc
-                    sleep 10
-                end
-            end
-        end
+      @sessions_mutex.synchronize do
+        @sessions[session_id].stop
+        @sessions.delete(session_id)
+      end
+    end
 
-        def run_server
-            raise 'Server is already running.' if @server_thread
-            raise 'Server already exist.' if @server
+    def stop_sessions
+      @sessions.each do |_session_id, session|
+        session.stop
+      end
+    end
 
-            @server = TCPServer.new '::', @port
+    def join
+      @runner&.join
+      @gc_thread&.join
+      @server_thread&.join
+    end
 
-            @server_thread = Thread.new do
-                loop do
-                    Thread.new(@server.accept) do |client|
-                        handle_client client
-                    end
-                end
-            end
+    def run
+      raise 'Client is already running.' if @runner
+      raise 'GC is already running.' if @gc
 
-            return @server_thread
+      @runner = Thread.new do
+        loop do
+          Thread.new(@socket.recvfrom(10_000)) do |buf|
+            handle_packet buf
+          end
         end
+      end
+      @gc_thread = Thread.new do
+        loop do
+          do_gc
+          sleep 10
+        end
+      end
+    end
 
-        def stop_server
-            raise 'Server thread is not running.' unless @server_thread
-
-            @server_thread.kill
-            @server_thread = nil
+    def run_server
+      raise 'Server is already running.' if @server_thread
+      raise 'Server already exist.' if @server
 
-            raise 'Server is not running.' unless @server
+      @server = TCPServer.new @host, @port
 
-            @server.close
-            @server = nil
+      @server_thread = Thread.new do
+        loop do
+          Thread.new(@server.accept) do |client|
+            handle_client client
+          end
         end
+      end
 
-        def stop
-            raise 'Session manager is not running.' unless @runner
+      return @server_thread
+    end
 
-            @runner.kill
-            @runner = nil
+    def stop_server
+      raise 'Server thread is not running.' unless @server_thread
 
-            raise 'Session GC is not running.' unless @gc_thread
+      @server_thread.kill
+      @server_thread = nil
 
-            @gc_thread.kill
-            @gc_thread = nil
-        end
+      raise 'Server is not running.' unless @server
 
-        def generate_session_id
-            Timeout::timeout(30, OutOfSessions, 'No session ID could be generated which has not yet been used.') do
-                session_id = rand(2 ** 32 - 1)
-                while @sessions.key? session_id
-                    session_id = rand(2 ** 32 - 1)
-                end
+      @server.close
+      @server = nil
+    end
 
-                return session_id
-            end
-        end
+    def stop
+      raise 'Session manager is not running.' unless @runner
 
-        private
-
-        def do_gc
-            $logger.debug 'Remove outdated sessions.'
-            @sessions.keys.each do |session_id|
-                session = @sessions[session_id]
-                # It is possible that sessions no longer exist here, as we may have session IDs that have already been deleted.
-                # However, we can ignore this aspect here, as we are the only function that deletes sessions.
-                if ! (session.tcp_handshake_complete && session.udp_handshake_complete)
-                    # Handshake incomplete
-                    if (Time.now.to_i - session.created.to_i) > 60
-                        # TCP and/or UDP take more than 60 seconds.
-                        $logger.debug "UDP handshake for session id #{session_id} timed out."
-                        del_session session_id
-                    end
-                elsif (Time.now.to_i - session.last_rx.to_i) > 30
-                    # 30 seconds have elapsed since the last ping from the peer was received. The peer is probably dead.
-                    $logger.debug "Session id #{session_id} without activity for over thirty seconds."
-                    del_session session_id
-                end
-            end
-        end
+      @runner.kill
+      @runner = nil
 
-        def handle_packet buf
-            rxtime = Time.now
-
-            peeraddr = buf[1][2]
-            peerport = buf[1][1]
-            $logger.debug "Packet received from #{peeraddr} port #{peerport}."
-
-            packet = MessagePack.unpack(buf[0])
-
-            # Check whether the Magic Number is the correct one.
-            if packet['M'] != 11181
-                $logger.warn 'Package contains incorrect magic number. Processing is canceled.'
-                return
-            end
-
-            type = packet['Y'].chr
-            case type
-            when 'h'
-                handle_udp_handshake packet, peeraddr, peerport
-            when 't'
-                handle_ping packet, rxtime, peeraddr, peerport
-            else
-                $logger.warn "Package is of unknown type: #{type}"
-            end
-        end
+      raise 'Session GC is not running.' unless @gc_thread
 
-        def handle_udp_handshake packet, peeraddr, peerport
-            session_id = packet['S']
-            session = @sessions[session_id]
-            if session
-                if packet['V'] != 3
-                    $logger.warn "UDP handshake uses an unsupported version: #{packet['V']}"
-                    return
-                end
-
-                session.set_endpoint peeraddr, peerport
-
-                if ! session.madebyme
-                    # If the session was not started by me, the other peer expects a
-                    # confirmation of the handshake in which the same is sent back.
-                    $logger.debug "Send UDP Handshake back for session id #{session_id}."
-                    session.send_udp_handshake
-                end
-
-                if session.udp_handshake_complete
-                    $logger.warn 'UDP handshake is received, although a previous one was already successful.'
-                    return
-                end
-
-                session.udp_handshake_recived
-                $logger.info "UDP handshake for session ID #{session_id} was successful."
-
-                session.start_pinger
-            else
-                $logger.warn 'UDP handshake received for uninitiated session.'
-                return
-            end
+      @gc_thread.kill
+      @gc_thread = nil
+    end
+
+    def generate_session_id
+      Timeout.timeout(30, OutOfSessions, 'No session ID could be generated which has not yet been used.') do
+        loop do
+          session_id = rand (2**32) - 1
+          return session_id unless @sessions.key? session_id
         end
+      end
+    end
 
-        def handle_ping packet, rxtime, peeraddr, peerport
-            session_id = packet['S']
-            session = @sessions[session_id]
-            if session && session.tcp_handshake_complete && session.udp_handshake_complete
-                session.set_endpoint peeraddr, peerport
-                session.handle_ping packet, rxtime, peeraddr
-            else
-                $logger.warn "Ping packet received for non-initiated session id #{session_id}."
-            end
+    private
+
+    def do_gc
+      $logger.debug 'Remove outdated sessions.'
+      # rubocop:disable Style/HashEachMethods
+      # You cannot run through a map and edit it at the same time. Since this is necessary due to the threading,
+      # a snapshot of the key variable is run through.
+      @sessions.keys.each do |session_id|
+        # rubocop:enable Style/HashEachMethods
+
+        session = @sessions[session_id]
+        # It is possible that sessions no longer exist here, as we may have session IDs that have already been deleted.
+        # However, we can ignore this aspect here, as we are the only function that deletes sessions.
+        if !(session.tcp_handshake_complete && session.udp_handshake_complete)
+          # Handshake incomplete
+          if (Time.now.to_i - session.created.to_i) > 60
+            # TCP and/or UDP take more than 60 seconds.
+            $logger.debug "UDP handshake for session id #{session_id} timed out."
+            del_session session_id
+          end
+        elsif (Time.now.to_i - session.last_rx.to_i) > 30
+          # 30 seconds have elapsed since the last ping from the peer was received. The peer is probably dead.
+          $logger.debug "Session id #{session_id} without activity for over thirty seconds."
+          del_session session_id
         end
+      end
+    end
+
+    def request_session(session)
+      session.do_tcp_handshake2
 
-        def handle_client(client)
-            host = client.peeraddr[3]
-            port = client.peeraddr[1]
-            session = SPing::Session.new host, port, @socket, false
-
-            $logger.debug "Session request from host #{host} port #{port}."
-
-            begin
-                session.do_tcp_handshake1 client, self.generate_session_id
-            rescue Errno::ECONNRESET, EOFError, IO::TimeoutError, TCPHandshakeError => e
-                $logger.warn "Could not establish a new session with Peer: #{e.message}"
-                return
-            rescue OutOfSessions => e
-                $logger.error "Could not establish a new session with Peer: #{e.message}"
-                return
-            end
-        
-            @sessions[session.session_id] = session
+      @sessions_mutex.synchronize do
+        unless @sessions.key? session.session_id
+          @sessions[session.session_id] = session
+          return session.session_id
         end
+      end
+
+      return nil
+    end
+
+    def handle_packet(buf)
+      rxtime = Time.now
+
+      peeraddr = buf[1][2]
+      peerport = buf[1][1]
+      $logger.debug "Packet received from #{peeraddr} port #{peerport}."
+
+      packet = MessagePack.unpack(buf[0]).to_h
+
+      if !packet.key?('M') ||
+         !packet.key?('Y') ||
+         !packet.key?('S') ||
+         !packet['M'].is_a?(Integer) ||
+         !packet['Y'].is_a?(Integer) ||
+         !packet['S'].is_a?(Integer)
+        raise InvalidMessageError, 'The peer has sent an invalid message. The packet is incorrectly coded.'
+      end
+
+      # Check whether the Magic Number is the correct one.
+      if packet['M'] != 11_181
+        raise UnknownPacketError, 'Package contains incorrect magic number. Processing is canceled.'
+      end
+
+      type = packet['Y'].chr
+      case type
+      when 'h'
+        handle_udp_handshake packet, peeraddr, peerport
+      when 't'
+        handle_ping packet, rxtime, peeraddr, peerport
+      else
+        raise UnknownPacketError, "Package is of unknown type: #{type}"
+      end
+    rescue MessagePack::MalformedFormatError => e
+      $logger.error "Packet cannot be decoded: #{e.message}"
+    rescue PeerError => e
+      $logger.error "Perr error: #{e.message}"
+    end
+
+    def handle_udp_handshake(packet, peeraddr, peerport)
+      if !(packet.keys - %w[M Y V S]).empty? ||
+         # M, Y are already checked in handle_packet from session manager
+         !packet['V'].is_a?(Integer)
+        raise InvalidMessageError, 'The peer has sent an invalid message. The handshake packet is incorrectly coded.'
+      end
+
+      session_id = packet['S']
+      session = @sessions[session_id]
+      raise UnknownSessionError, 'UDP handshake received for uninitiated session.' unless session
+      raise UnknownVersionError, "UDP handshake uses an unsupported version: #{packet['V']}" if packet['V'] != 3
+
+      session.set_endpoint peeraddr, peerport
+
+      unless session.madebyme
+        # If the session was not started by me, the other peer expects a
+        # confirmation of the handshake in which the same is sent back.
+        $logger.debug "Send UDP Handshake back for session id #{session_id}."
+        session.send_udp_handshake
+      end
+
+      if session.udp_handshake_complete
+        $logger.warn 'UDP handshake is received, although a previous one was already successful.'
+        return
+      end
+
+      session.udp_handshake_recived
+      $logger.info "UDP handshake for session ID #{session_id} was successful."
+
+      session.start_pinger
+    end
+
+    def handle_ping(packet, rxtime, peeraddr, peerport)
+      session_id = packet['S']
+      session = @sessions[session_id]
+      unless session&.tcp_handshake_complete && session&.udp_handshake_complete
+        raise UnknownSessionError, "Ping packet received for non-initiated session id #{session_id}."
+      end
+
+      session.set_endpoint peeraddr, peerport
+      session.handle_ping packet, rxtime, peeraddr
+    end
+
+    def handle_client(client)
+      host = client.peeraddr[3]
+      port = client.peeraddr[1]
+      session = SPing::Session.new host, port, @socket, false
+
+      $logger.debug "Session request from host #{host} port #{port}."
+
+      session_id = nil
+
+      @sessions_mutex.synchronize do
+        session_id = generate_session_id
+        @sessions[session_id] = session
+      end
+
+      session.do_tcp_handshake1 client, session_id
+    rescue Errno::ECONNRESET, EOFError, IO::TimeoutError, TCPHandshakeError => e
+      $logger.warn "Could not establish a new session with Peer: #{e.message}"
+      del_session session_id
+    rescue OutOfSessions => e
+      $logger.error "Could not establish a new session with Peer: #{e.message}"
+      del_session session_id
     end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sping
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.4
 platform: ruby
 authors:
 - Marek Küthe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-07 00:00:00.000000000 Z
+date: 2023-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -43,6 +43,7 @@ files:
 - LICENSE
 - README.md
 - bin/sping
+- lib/errors.rb
 - lib/last_acks.rb
 - lib/session.rb
 - lib/session_manager.rb
@@ -68,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: Reimplementation of sping in Ruby.