pcapr-local 0.1.10

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

@@ -0,0 +1,123 @@
+# 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/mu/pcap/sctp/chunk/data.rb

@@ -0,0 +1,134 @@
+# 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/mu/pcap/sctp/chunk/init.rb

@@ -0,0 +1,100 @@
+# 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/mu/pcap/sctp/chunk/init_ack.rb

@@ -0,0 +1,68 @@
+# 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/mu/pcap/sctp/parameter.rb

@@ -0,0 +1,110 @@
+# 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'