woolen_common 0.0.1

data/lib/woolen_common/pcap/mu/pcap/sctp/chunk.rb

@@ -0,0 +1,124 @@
+# -*- encoding : utf-8 -*-
+# http://www.mudynamics.com
+# http://labs.mudynamics.com
+# http://www.pcapr.net
+
+module Mu
+    class Pcap
+        class SCTP
+
+            class Chunk < Packet
+                attr_accessor :type, :flags, :size
+
+                def initialize
+                    super
+
+                    @type = 0
+                    @flags = 0
+                    @size = 0
+                end
+
+                def self.from_bytes bytes
+                    # Basic validation
+                    Pcap.assert(bytes.length >= 4,
+                                "Truncated chunk header: 4 > #{bytes.length}")
+
+                    # Read chunk header
+                    type, flags, size = bytes.unpack('CCn')
+
+                    # Validate chunk size
+                    Pcap.assert(bytes.length >= size,
+                                "Truncated chunk: #{size} set, #{bytes.length} available")
+
+                    # Create chunk based on type
+                    case type
+                        when CHUNK_DATA
+                            chunk = Data.from_bytes(flags, size, bytes[4..-1])
+                        when CHUNK_INIT
+                            chunk = Init.from_bytes(flags, size, bytes[4..-1])
+                        when CHUNK_INIT_ACK
+                            chunk = InitAck.from_bytes(flags, size, bytes[4..-1])
+                        when CHUNK_SACK
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_HEARTBEAT
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_HEARTBEAT_ACK
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_ABORT
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_SHUTDOWN
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_SHUTDOWN_ACK
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_ERROR
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_COOKIE_ECHO
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_COOKIE_ACK
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_ECNE
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_CWR
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_SHUTDOWN_COMPLETE
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_AUTH
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_ASCONF_ACK
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_PADDING
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_FORWARD_TSN
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        when CHUNK_ASCONF
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                        else
+                            chunk = dummy_chunk(type, flags, size, bytes)
+                    end
+
+                    # Return the result
+                    return chunk
+                end
+
+                def write io, ip
+                    header = [@type, @flags, @size].pack('CCn')
+
+                    # Write Chunk header followed by the payload
+                    io.write(header)
+                    io.write(@payload_raw)
+                end
+
+                def padded_size
+                    if 0 == @size % 4
+                        return @size
+                    else
+                        return (@size + 4 - (@size % 4))
+                    end
+                end
+
+                def to_s
+                    return "chunk(%d, %d, %d)" % [@type, @flags, @size]
+                end
+
+                def self.dummy_chunk type, flags, size, bytes
+                    # Create new dummy chunk
+                    chunk = Chunk.new
+                    chunk.type = type
+                    chunk.flags = flags
+                    chunk.size = size
+
+                    # Save the payload
+                    chunk.payload_raw = chunk.payload = bytes[4..chunk.padded_size]
+
+                    # Return the result
+                    return chunk
+                end
+            end # class Chunk
+
+        end # class SCTP
+    end # class Pcap
+end # module Mu
+
+require 'mu/pcap/sctp/chunk/data'
+require 'mu/pcap/sctp/chunk/init'
+require 'mu/pcap/sctp/chunk/init_ack'

data/lib/woolen_common/pcap/mu/pcap/sctp/chunk/data.rb

@@ -0,0 +1,135 @@
+# -*- encoding : utf-8 -*-
+# http://www.mudynamics.com
+# http://labs.mudynamics.com
+# http://www.pcapr.net
+
+module Mu
+    class Pcap
+        class SCTP
+            class Chunk
+
+                class Data < Chunk
+                    FLAG_LAST_SEG = 0x01
+                    FLAG_FIRST_SEG = 0x02
+                    FLAG_UNORDERED = 0x04
+
+                    attr_accessor :tsn, :sid, :ssn, :ppid
+
+                    def initialize
+                        super
+
+                        @type = CHUNK_DATA
+                        @tsn = 0
+                        @sid = 0
+                        @ssn = 0
+                        @ppid = 0
+                    end
+
+                    def self.from_bytes flags, size, bytes
+                        # Basic validation
+                        Pcap.assert(bytes.length >= 12,
+                                    "Truncated data chunk header: 12 > #{bytes.length}")
+
+                        # Read init chunk header
+                        tsn, sid, ssn, ppid = bytes.unpack('NnnN')
+
+                        # Create data chunk
+                        data = Data.new
+                        data.flags = flags
+                        data.size = size
+                        data.tsn = tsn
+                        data.sid = sid
+                        data.ssn = ssn
+                        data.ppid = ppid
+
+                        # Save the payload
+                        data.payload_raw = data.payload = bytes[12..size - 5]
+
+                        # Return the result
+                        return data
+                    end
+
+                    def write io, ip
+                        chunk_header = [@type, @flags, @size].pack('CCn')
+                        data_header = [@tsn, @sid, @ssn, @ppid].pack('NnnN')
+
+                        # Write Chunk header followed by the Data chunk header and payload
+                        io.write(chunk_header)
+                        io.write(data_header)
+                        io.write(@payload_raw)
+
+                        # Write padding, if necessary
+                        if size < padded_size
+                            (padded_size - size).times do
+                                io.write("\x00")
+                            end
+                        end
+                    end
+
+                    def ordered?
+                        if 0 == @flags[2]
+                            return true
+                        else
+                            return false
+                        end
+                    end
+
+                    def first_segment?
+                        if 1 == @flags[1] and 0 == @flags[0]
+                            return true
+                        else
+                            return false
+                        end
+                    end
+
+                    def last_segment?
+                        if 0 == @flags[1] and 1 == @flags[0]
+                            return true
+                        else
+                            return false
+                        end
+                    end
+
+                    def complete_segment?
+                        if 1 == @flags[1] and 1 == @flags[0]
+                            return true
+                        else
+                            return false
+                        end
+                    end
+
+                    def to_s
+                        flags_s = '['
+
+                        if ordered?
+                            flags_s += 'ordered, '
+                        else
+                            flags_s += 'unordered, '
+                        end
+
+                        if complete_segment?
+                            flags_s += 'complete segment'
+                        elsif first_segment?
+                            flags_s += 'first segment'
+                        elsif last_segment?
+                            flags_s += 'last segment'
+                        else
+                            flags_s += 'middle segment'
+                        end
+
+                        flags_s += ']'
+
+                        return "data(%s, %d, %d, %d, %d, %d, %s)" % [flags_s,
+                                                                     @size,
+                                                                     @tsn,
+                                                                     @sid,
+                                                                     @ssn,
+                                                                     @ppid,
+                                                                     @payload.inspect]
+                    end
+                end # class Data
+
+            end # class Chunk
+        end # class SCTP
+    end # class Pcap
+end # module Mu

data/lib/woolen_common/pcap/mu/pcap/sctp/chunk/init.rb

@@ -0,0 +1,101 @@
+# -*- encoding : utf-8 -*-
+# http://www.mudynamics.com
+# http://labs.mudynamics.com
+# http://www.pcapr.net
+
+module Mu
+    class Pcap
+        class SCTP
+            class Chunk
+
+                class Init < Chunk
+                    attr_accessor :init_tag, :a_rwnd, :o_streams, :i_streams, :init_tsn
+
+                    def initialize
+                        super
+
+                        @type = CHUNK_INIT
+                        @init_tag = 0
+                        @a_rwnd = 0
+                        @o_streams = 0
+                        @i_streams = 0
+                        @init_tsn = 0
+                        @payload = []
+                    end
+
+                    def self.from_bytes flags, size, bytes
+                        # Basic validation
+                        Pcap.assert(bytes.length >= 16,
+                                    "Truncated init chunk header: 16 > #{bytes.length}")
+
+                        # Read init chunk header
+                        init_tag, a_rwnd, o_streams, i_streams, init_tsn = bytes.unpack('NNnnN')
+
+                        # Create init chunk
+                        init = Init.new
+                        init.flags = flags
+                        init.size = size
+                        init.init_tag = init_tag
+                        init.a_rwnd = a_rwnd
+                        init.o_streams = o_streams
+                        init.i_streams = i_streams
+                        init.init_tsn = init_tsn
+
+                        # Initialize the counter
+                        length = 16
+
+                        # Collect the chunks
+                        while length < bytes.length
+                            # Parse new parameter from the bytes
+                            parameter = Parameter.from_bytes(bytes[length..-1])
+
+                            # Get parameter size with padding
+                            length += parameter.padded_size
+
+                            # Add chunk to the list
+                            init << parameter
+                        end
+
+                        # Return the result
+                        return init
+                    end
+
+                    def write io, ip
+                        chunk_header = [@type, @flags, @size].pack('CCn')
+                        init_header = [@init_tag,
+                                       @a_rwnd,
+                                       @o_streams,
+                                       @i_streams,
+                                       @init_tsn].pack('NNnnN')
+
+                        # Write Chunk header followed by the Init chunk header
+                        io.write(chunk_header)
+                        io.write(init_header)
+
+                        # Write each parameter
+                        @payload.each do |parameter|
+                            parameter.write(io, ip)
+                        end
+                    end
+
+                    def << parameter
+                        @payload << parameter
+                    end
+
+                    def to_s
+                        return "init(%d, %d, %d, %d, %d, %d, %s)" % [@size,
+                                                                     @init_tag,
+                                                                     @a_rwnd,
+                                                                     @o_streams,
+                                                                     @i_streams,
+                                                                     @init_tsn,
+                                                                     @payload.join(", ")]
+                    end
+                end # class Init
+
+            end # class Chunk
+        end # class SCTP
+    end # class Pcap
+end # module Mu
+
+require 'mu/pcap/sctp/parameter'

data/lib/woolen_common/pcap/mu/pcap/sctp/chunk/init_ack.rb

@@ -0,0 +1,69 @@
+# -*- encoding : utf-8 -*-
+# http://www.mudynamics.com
+# http://labs.mudynamics.com
+# http://www.pcapr.net
+
+module Mu
+    class Pcap
+        class SCTP
+            class Chunk
+
+                class InitAck < Init
+                    def initialize
+                        super
+
+                        @type = CHUNK_INIT_ACK
+                    end
+
+                    def self.from_bytes flags, size, bytes
+                        # Basic validation
+                        Pcap.assert(bytes.length >= 16,
+                                    "Truncated init_ack chunk header: 16 > #{bytes.length}")
+
+                        # Read init_ack chunk header
+                        init_tag, a_rwnd, o_streams, i_streams, init_tsn = bytes.unpack('NNnnN')
+
+                        # Create init chunk
+                        init_ack = InitAck.new
+                        init_ack.flags = flags
+                        init_ack.size = size
+                        init_ack.init_tag = init_tag
+                        init_ack.a_rwnd = a_rwnd
+                        init_ack.o_streams = o_streams
+                        init_ack.i_streams = i_streams
+                        init_ack.init_tsn = init_tsn
+
+                        # Initialize the counter
+                        length = 16
+
+                        # Collect the chunks
+                        while length < bytes.length
+                            # Parse new parameter from the bytes
+                            parameter = Parameter.from_bytes(bytes[length..-1])
+
+                            # Get parameter size with padding
+                            length += parameter.padded_size
+
+                            # Add chunk to the list
+                            init_ack << parameter
+                        end
+
+                        # Return the result
+                        return init_ack
+                    end
+
+                    def to_s
+                        return "init_ack(%d, %d, %d, %d, %d, %d, %s)" % [@size,
+                                                                         @init_tag,
+                                                                         @a_rwnd,
+                                                                         @o_streams,
+                                                                         @i_streams,
+                                                                         @init_tsn,
+                                                                         @payload.join(", ")]
+                    end
+                end # class InitAck
+
+            end # class Chunk
+        end # class SCTP
+    end # class Pcap
+end # module Mu

data/lib/woolen_common/pcap/mu/pcap/sctp/parameter.rb

@@ -0,0 +1,111 @@
+# -*- encoding : utf-8 -*-
+# http://www.mudynamics.com
+# http://labs.mudynamics.com
+# http://www.pcapr.net
+
+module Mu
+    class Pcap
+        class SCTP
+
+            class Parameter < Packet
+                attr_accessor :type, :size
+
+                def initialize
+                    super
+
+                    @type = 0
+                    @size = 0
+                end
+
+                def self.from_bytes bytes
+                    # Basic validation
+                    Pcap.assert(bytes.length >= 4,
+                                "Truncated parameter header: 4 > #{bytes.length}")
+
+                    # Read chunk header
+                    type, size = bytes.unpack('nn')
+
+                    # Validate chunk size
+                    Pcap.assert(bytes.length >= size,
+                                "Truncated parameter: #{size} set, #{bytes.length} available")
+
+                    # Create chunk based on type
+                    case type
+                        when PARAM_IPV4
+                            parameter = IpAddress.from_bytes(type, size, bytes[4..-1])
+                        when PARAM_IPV6
+                            parameter = IpAddress.from_bytes(type, size, bytes[4..-1])
+                        when PARAM_STATE_COOKIE
+                            parameter = dummy_parameter(type, size, bytes)
+                        when PARAM_COOKIE_PRESERVATIVE
+                            parameter = dummy_parameter(type, size, bytes)
+                        when PARAM_HOST_NAME_ADDR
+                            parameter = dummy_parameter(type, size, bytes)
+                        when PARAM_SUPPORTED_ADDR_TYPES
+                            parameter = dummy_parameter(type, size, bytes)
+                        when PARAM_ECN
+                            parameter = dummy_parameter(type, size, bytes)
+                        when PARAM_RANDOM
+                            parameter = dummy_parameter(type, size, bytes)
+                        when PARAM_CHUNK_LIST
+                            parameter = dummy_parameter(type, size, bytes)
+                        when PARAM_HMAC_ALGORITHM
+                            parameter = dummy_parameter(type, size, bytes)
+                        when PARAM_PADDING
+                            parameter = dummy_parameter(type, size, bytes)
+                        when PARAM_SUPPORTED_EXTENSIONS
+                            parameter = dummy_parameter(type, size, bytes)
+                        when PARAM_FORWARD_TSN
+                            parameter = dummy_parameter(type, size, bytes)
+                        when PARAM_SET_PRIMARY_ADDR
+                            parameter = dummy_parameter(type, size, bytes)
+                        when PARAM_ADAPTATION_LAYER_INDICATION
+                            parameter = dummy_parameter(type, size, bytes)
+                        else
+                            parameter = dummy_parameter(type, size, bytes)
+                    end
+
+                    # Return the result
+                    return parameter
+                end
+
+                def write io, ip
+                    header = [@type, @size].pack('nn')
+
+                    # Write Parameter header followed by the payload
+                    io.write(header)
+                    io.write(@payload_raw)
+                end
+
+                def padded_size
+                    if 0 == @size % 4
+                        return @size
+                    else
+                        return (@size + 4 - (@size % 4))
+                    end
+                end
+
+                def to_s
+                    return "parameter(%d, %d)" % [@type, @size]
+                end
+
+                def self.dummy_parameter type, size, bytes
+                    # Create new dummy parameter
+                    parameter = Parameter.new
+                    parameter.type = type
+                    parameter.size = size
+
+                    # Save the payload
+                    parameter.payload = bytes[4..parameter.padded_size - 1]
+                    parameter.payload_raw = parameter.payload
+
+                    # Return the result
+                    return parameter
+                end
+            end # class Parameter
+
+        end # class SCTP
+    end # class Pcap
+end # module Mu
+
+require 'mu/pcap/sctp/parameter/ip_address'