DIY-pcap 0.4.1 → 0.4.3

data/lib/diy/parser/mu/pcap/sctp/chunk/init.rb

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

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

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