packetgen 3.3.1 → 3.3.2

data/lib/packetgen/header/sctp/error.rb

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+
+# This file is part of PacketGen
+# See https://github.com/lemontree55/packetgen for more informations
+# Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
+# Copyright (C) 2024 LemonTree55 <lenontree@proton.me>
+# This program is published under MIT license.
+
+module PacketGen
+  module Header
+    class SCTP
+      # Common methods to all error causes
+      # @author Sylvain Daubert
+      module ErrorMixin
+        include Padded32
+
+        # Get error name
+        # @return [String]
+        def error_name
+          self.class.name.split('::').last.delete_suffix('Error')
+        end
+
+        # @return [String]
+        def to_human
+          "<#{error_name}: #{value}>"
+        end
+      end
+
+      Error = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                        length_class: Types::Int16,
+                                        field_in_length: 'TLV')
+
+      # Base class/factory for {AbortChunk} and {ErrorChunk} error causes
+      # @author Sylvain Daubert
+      class Error
+        include ErrorMixin
+
+        # Error Causes/Types
+        TYPES = {
+          'InvalidStreamId' => 1,
+          'MissingMandatoryParameter' => 2,
+          'StaleCookie' => 3,
+          'OutOfResource' => 4,
+          'UnresolvableAddress' => 5,
+          'UnrecognizedChunkType' => 6,
+          'InvalidMandatoryParameter' => 7,
+          'UnrecognizedParameters' => 8,
+          'NoUserData' => 9,
+          'CookieReceivedWhileShuttingDown' => 10,
+          'RestartAssociationWithNewAddress' => 11,
+          'UserInitiatedAbort' => 12,
+          'ProtocolViolation' => 13
+        }.freeze
+
+        # @param [Object] value
+        def from_human(value)
+          if value.is_a?(self[:value].class)
+            self[:value] = value
+          else
+            self[:value].from_human(value)
+          end
+        end
+      end
+      Error.define_type_enum(Error::TYPES)
+
+      # Handle array of {Error} and {ErrorMixin} classes.
+      # @author Sylvain Daubert
+      class ArrayOfError < Types::Array
+        set_of Error
+
+        private
+
+        # @param [Error,ErrorMixin] error
+        def real_type(error)
+          type_name = Error::TYPES.key(error.type)
+          return error.class if type_name.nil?
+
+          SCTP.const_get(real_klass_name(type_name)) || error.class
+        end
+
+        def real_klass_name(type_name)
+          type_name + 'Error' # rubocop:disable Style/StringConcatenation
+        end
+      end
+
+      InvalidStreamIdError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                       length_class: Types::Int16,
+                                                       value_class: Types::Int32,
+                                                       field_in_length: 'TLV')
+
+      # InvalidStreamIdentifier error
+      # @author Sylvain Daubert
+      class InvalidStreamIdError
+        include ErrorMixin
+
+        # Get stream Id value
+        # @return [Integer]
+        def stream_identifier
+          self.value >> 16
+        end
+
+        # Set stream Id value
+        # @param [Integer] stream_id
+        # @return [Integer]
+        def stream_identifier=(stream_id)
+          self.value = (stream_id & 0xffff) << 16
+          stream_id
+        end
+
+        # @return [::String]
+        def to_human
+          "<#{error_name}: #{stream_identifier}>"
+        end
+
+        # @param [Integer] val
+        def from_human(val)
+          super
+          self.value <<= 16 if self[:value] < Types::Int
+        end
+      end
+      InvalidStreamIdError.define_type_enum(Error::TYPES)
+      InvalidStreamIdError.define_type_default('InvalidStreamId')
+
+      MissingMandatoryParameterError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                                 length_class: Types::Int16,
+                                                                 value_class: Types::ArrayOfInt16,
+                                                                 field_in_length: 'TLV')
+
+      # MissingMandatoryParameter error. Indicate that one or more
+      # mandatory TLV parameters are missing in a received {InitChunk}
+      # or {InitAckChunk}.
+      # @author Sylvain Daubert
+      class MissingMandatoryParameterError
+        include ErrorMixin
+
+        # @return [::String]
+        def to_human
+          "<#{error_name}: #{self[:value].to_human}>"
+        end
+      end
+      MissingMandatoryParameterError.define_type_enum(Error::TYPES)
+      MissingMandatoryParameterError.define_type_default('MissingMandatoryParameter')
+
+      StaleCookieError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                   length_class: Types::Int16,
+                                                   value_class: Types::Int32,
+                                                   field_in_length: 'TLV')
+
+      # StaleCookie error. Indicates the receipt of a valid State Cookie that
+      # has expired.
+      # @author Sylvain Daubert
+      class StaleCookieError
+        include ErrorMixin
+      end
+      StaleCookieError.define_type_enum(Error::TYPES)
+      StaleCookieError.define_type_default('StaleCookie')
+
+      OutOfResourceError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                     length_class: Types::Int16,
+                                                     field_in_length: 'TLV')
+
+      # Out of ressource error. Indicates that the sender is out of resource.
+      # @author Sylvain Daubert
+      class OutOfResourceError
+        include ErrorMixin
+
+        # @return [::String]
+        def to_human
+          "<#{error_name}>"
+        end
+      end
+      OutOfResourceError.define_type_enum(Error::TYPES)
+      OutOfResourceError.define_type_default('OutOfResource')
+
+      UnresolvableAddressError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                           length_class: Types::Int16,
+                                                           value_class: Parameter,
+                                                           field_in_length: 'TLV')
+
+      # Out of ressource error. Indicates that the sender is out of resource.
+      # @author Sylvain Daubert
+      class UnresolvableAddressError
+        include ErrorMixin
+
+        # Set +value+ by accepting {ParameterMixin} classes.
+        # @param [ParameterMixin] val
+        # @return [ParameterMixin]
+        def value=(val)
+          if val.is_a?(ParameterMixin)
+            self[:value] = val
+            calc_length
+            val
+          else
+            super
+          end
+        end
+
+        # @return [::String]
+        def to_human
+          "<#{error_name}: #{self[:value].to_human}>"
+        end
+      end
+      UnresolvableAddressError.define_type_enum(Error::TYPES)
+      UnresolvableAddressError.define_type_default('UnresolvableAddress')
+
+      UnrecognizedChunkTypeError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                             length_class: Types::Int16,
+                                                             value_class: BaseChunk,
+                                                             field_in_length: 'TLV')
+
+      # Unrecognized chunk type error. The receiver does not understand the chunk and the upper bits of the 'Chunk Type'
+      # are set to 01 or 11.
+      # @author Sylvain Daubert
+      class UnrecognizedChunkTypeError
+        include ErrorMixin
+
+        # @return [::String]
+        def to_human
+          "<#{error_name}: #{self[:value].to_human}>"
+        end
+      end
+      UnrecognizedChunkTypeError.define_type_enum(Error::TYPES)
+      UnrecognizedChunkTypeError.define_type_default('UnrecognizedChunkType')
+
+      InvalidMandatoryParameterError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                                 length_class: Types::Int16,
+                                                                 field_in_length: 'TLV')
+
+      # Invalid mandatory parameter error. Returned to the originator of an INIT or INIT ACK chunk when one of the
+      # mandatory parameters is set to an invalid value.
+      # @author Sylvain Daubert
+      class InvalidMandatoryParameterError
+        include ErrorMixin
+
+        # @return [::String]
+        def to_human
+          "<#{error_name}>"
+        end
+      end
+      InvalidMandatoryParameterError.define_type_enum(Error::TYPES)
+      InvalidMandatoryParameterError.define_type_default('InvalidMandatoryParameter')
+
+      UnrecognizedParametersError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                              length_class: Types::Int16,
+                                                              value_class: ArrayOfParameter,
+                                                              field_in_length: 'TLV')
+
+      # Unrecognized parameters error. Returned to the originator of the INIT ACK chunk if the receiver does not
+      # recognize one or more Optional TLV parameters in the INIT ACK chunk.
+      # @author Sylvain Daubert
+      class UnrecognizedParametersError
+        include ErrorMixin
+
+        # @return [::String]
+        def to_human
+          "<#{error_name}: #{self[:value].to_human}>"
+        end
+      end
+      UnrecognizedParametersError.define_type_enum(Error::TYPES)
+      UnrecognizedParametersError.define_type_default('UnrecognizedParameters')
+
+      NoUserDataError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                  length_class: Types::Int16,
+                                                  value_class: Types::Int32,
+                                                  field_in_length: 'TLV')
+
+      # No user data error. Returned when a received {DataChunk} was received with no data.
+      # @author Sylvain Daubert
+      class NoUserDataError
+        include ErrorMixin
+      end
+      NoUserDataError.define_type_enum(Error::TYPES)
+      NoUserDataError.define_type_default('NoUserData')
+
+      CookieReceivedWhileShuttingDownError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                                       length_class: Types::Int16,
+                                                                       field_in_length: 'TLV')
+
+      # Cookie received while shutting down error.
+      # A COOKIE ECHO chunk was received while the endpoint was in the SHUTDOWN-ACK-SENT state.
+      # @author Sylvain Daubert
+      class CookieReceivedWhileShuttingDownError
+        include ErrorMixin
+
+        # @return [::String]
+        def to_human
+          "<#{error_name}>"
+        end
+      end
+      CookieReceivedWhileShuttingDownError.define_type_enum(Error::TYPES)
+      CookieReceivedWhileShuttingDownError.define_type_default('CookieReceivedWhileShuttingDown')
+
+      RestartAssociationWithNewAddressError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                                        length_class: Types::Int16,
+                                                                        value_class: ArrayOfParameter,
+                                                                        field_in_length: 'TLV')
+
+      # Cookie received while shutting down error.
+      # A COOKIE ECHO chunk was received while the endpoint was in the SHUTDOWN-ACK-SENT state.
+      # @author Sylvain Daubert
+      class RestartAssociationWithNewAddressError
+        include ErrorMixin
+
+        # @return [::String]
+        def to_human
+          "<#{error_name}: #{self[:value].to_human}>"
+        end
+      end
+      RestartAssociationWithNewAddressError.define_type_enum(Error::TYPES)
+      RestartAssociationWithNewAddressError.define_type_default('RestartAssociationWithNewAddress')
+
+      UserInitiatedAbortError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                          length_class: Types::Int16,
+                                                          field_in_length: 'TLV')
+
+      # User-Initiated abort error.
+      # @author Sylvain Daubert
+      class UserInitiatedAbortError
+        include ErrorMixin
+
+        # @return [::String]
+        def to_human
+          "<#{error_name}>"
+        end
+      end
+      UserInitiatedAbortError.define_type_enum(Error::TYPES)
+      UserInitiatedAbortError.define_type_default('UserInitiatedAbort')
+
+      ProtocolViolationError = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                         length_class: Types::Int16,
+                                                         field_in_length: 'TLV')
+
+      # Protocol violation error.
+      # @author Sylvain Daubert
+      class ProtocolViolationError
+        include ErrorMixin
+
+        # @return [::String]
+        def to_human
+          "<#{error_name}>"
+        end
+      end
+      ProtocolViolationError.define_type_enum(Error::TYPES)
+      ProtocolViolationError.define_type_default('ProtocolViolation')
+    end
+  end
+end

data/lib/packetgen/header/sctp/padded32.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# This file is part of PacketGen
+# See https://github.com/lemontree55/packetgen for more informations
+# Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
+# Copyright (C) 2024 LemonTree55 <lenontree@proton.me>
+# This program is published under MIT license.
+
+module PacketGen
+  module Header
+    class SCTP
+      # Mixin to handle 32-bit padding in SCTP classes
+      module Padded32
+        # Handle padding
+        # @param [Bool] no_padding
+        # @return [::String]
+        def to_s(no_padding: false)
+          s = super()
+          return s if no_padding
+
+          padlen = -(s.size % -4)
+          s << force_binary("\x00" * padlen)
+        end
+
+        # Say if binary string is padded
+        # @return [bool]
+        def padded?
+          str = to_s(no_padding: true)
+          (str.size % 4).positive?
+        end
+      end
+    end
+  end
+end

data/lib/packetgen/header/sctp/parameter.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+# This file is part of PacketGen
+# See https://github.com/lemontree55/packetgen for more informations
+# Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
+# Copyright (C) 2024 LemonTree55 <lenontree@proton.me>
+# This program is published under MIT license.
+
+module PacketGen
+  module Header
+    class SCTP
+      # Common methods to Init and InitAck parameters
+      # @author Sylvain Daubert
+      module ParameterMixin
+        include Padded32
+
+        # Get parameter name
+        # @return [String]
+        def parameter_name
+          self.class.name.split('::').last.delete_suffix('Parameter')
+        end
+
+        # @return [String]
+        def to_human
+          "<#{parameter_name}: #{value}>"
+        end
+      end
+
+      Parameter = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                            length_class: Types::Int16,
+                                            field_in_length: 'TLV')
+      # Base class/factory for {InitChunk} and {InitAckChunk} parameters
+      # @author Sylvain Daubert
+      class Parameter
+        include ParameterMixin
+
+        # Paramter Types
+        TYPES = {
+          'IPv4' => 5,
+          'IPv6' => 6,
+          'StateCookie' => 7,
+          'Unrecognized' => 8,
+          'CookiePreservative' => 9,
+          'Hostname' => 11,
+          'SupportedAddrTypes' => 12,
+          'ECN' => 32_768
+        }.freeze
+
+        # @return [::String]
+        def to_human
+          "<#{human_type}: #{self[:value].inspect}>"
+        end
+
+        # @param [Object] value
+        def from_human(value)
+          if value.is_a?(self[:value].class)
+            self[:value] = value
+          else
+            self[:value].from_human(value)
+          end
+        end
+      end
+      Parameter.define_type_enum(Parameter::TYPES)
+
+      IPv4Parameter = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                length_class: Types::Int16,
+                                                value_class: IP::Addr,
+                                                field_in_length: 'TLV')
+
+      # IPv4 address parameter
+      # @author Sylvain Daubert
+      class IPv4Parameter
+        include ParameterMixin
+      end
+      IPv4Parameter.define_type_enum(Parameter::TYPES)
+      IPv4Parameter.define_type_default('IPv4')
+
+      IPv6Parameter = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                length_class: Types::Int16,
+                                                value_class: IPv6::Addr,
+                                                field_in_length: 'TLV')
+
+      # IPv6 address parameter
+      # @author Sylvain Daubert
+      class IPv6Parameter
+        include ParameterMixin
+      end
+      IPv6Parameter.define_type_enum(Parameter::TYPES)
+      IPv6Parameter.define_type_default('IPv6')
+
+      StateCookieParameter = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                       length_class: Types::Int16,
+                                                       value_class: Types::String,
+                                                       field_in_length: 'TLV')
+
+      # State Cookie parameter
+      # @author Sylvain Daubert
+      class StateCookieParameter
+        include ParameterMixin
+
+        # @return [::String]
+        def to_human
+          "<#{parameter_name}: #{self[:value].inspect}>"
+        end
+      end
+      StateCookieParameter.define_type_enum(Parameter::TYPES)
+      StateCookieParameter.define_type_default('StateCookie')
+
+      UnrecognizedParameter = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                        length_class: Types::Int16,
+                                                        value_class: Parameter,
+                                                        field_in_length: 'TLV')
+
+      # Unrecognized parameter
+      # @author Sylvain Daubert
+      class UnrecognizedParameter
+        include ParameterMixin
+
+        # @return [::String]
+        def to_human
+          "<#{parameter_name}: #{self[:value].to_human}"
+        end
+      end
+      UnrecognizedParameter.define_type_enum(Parameter::TYPES)
+      UnrecognizedParameter.define_type_default('Unrecognized')
+
+      HostnameParameter = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                    length_class: Types::Int16,
+                                                    value_class: Types::CString,
+                                                    field_in_length: 'TLV')
+
+      # Hostname address parameter
+      # @author Sylvain Daubert
+      class HostnameParameter
+        include ParameterMixin
+      end
+      HostnameParameter.define_type_enum(Parameter::TYPES)
+      HostnameParameter.define_type_default('Hostname')
+
+      SupportedAddrTypesParameter = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                              length_class: Types::Int16,
+                                                              value_class: Types::ArrayOfInt16,
+                                                              field_in_length: 'TLV')
+
+      # Supported address types parameter
+      # @author Sylvain Daubert
+      class SupportedAddrTypesParameter
+        include ParameterMixin
+
+        # @return [::String]
+        def to_human
+          types = self[:value].map(&:to_i).map do |int16|
+            Parameter::TYPES.key(int16) || int16.to_s
+          end.join(',')
+          "<#{parameter_name}: #{types}>"
+        end
+      end
+      SupportedAddrTypesParameter.define_type_enum(Parameter::TYPES)
+      SupportedAddrTypesParameter.define_type_default('SupportedAddrTypes')
+
+      CookiePreservativeParameter = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                              length_class: Types::Int16,
+                                                              value_class: Types::Int32,
+                                                              field_in_length: 'TLV')
+
+      # Cookie Preservative parameter
+      # @author Sylvain Daubert
+      class CookiePreservativeParameter
+        include ParameterMixin
+
+        # @return [::String]
+        def to_human
+          "<#{parameter_name}: #{value}>"
+        end
+      end
+      CookiePreservativeParameter.define_type_enum(Parameter::TYPES)
+      CookiePreservativeParameter.define_type_default('CookiePreservative')
+
+      ECNParameter = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                               length_class: Types::Int16,
+                                               field_in_length: 'TLV')
+
+      # ECN parameter
+      # @author Sylvain Daubert
+      class ECNParameter
+        include ParameterMixin
+
+        # @return [::String]
+        def to_human
+          "<#{parameter_name}>"
+        end
+      end
+      ECNParameter.define_type_enum(Parameter::TYPES)
+      ECNParameter.define_type_default('ECN')
+
+      HearbeatInfoParameter = Types::AbstractTLV.create(type_class: Types::Int16Enum,
+                                                        length_class: Types::Int16,
+                                                        field_in_length: 'TLV')
+
+      # Heartbeat Information parameter
+      # @author Sylvain Daubert
+      class HearbeatInfoParameter
+        include ParameterMixin
+      end
+      HearbeatInfoParameter.define_type_enum({ 'HearbeatInfo' => 1 }.freeze)
+      HearbeatInfoParameter.define_type_default('HearbeatInfo')
+
+      # Array of {Parameter}s and {ParameterMixin}.
+      # @author Sylvain Daubert
+      class ArrayOfParameter < Types::Array
+        set_of Parameter
+
+        private
+
+        # Get real type from {Parameter} type
+        def real_type(param)
+          type_name = Parameter::TYPES.key(param.type)
+          return param.class if type_name.nil?
+
+          SCTP.const_get(real_klass_name(type_name)) || param.class
+        end
+
+        def real_klass_name(type_name)
+          type_name + 'Parameter' # rubocop:disable Style/StringConcatenation
+        end
+      end
+    end
+  end
+end