pio 0.18.2 → 0.19.0

data/features/step_definitions/packet_data_steps.rb

@@ -1,42 +1,58 @@
-Given(/^a packet data file "(.*?)"$/) do |name|
-  path = File.expand_path(File.join(File.dirname(__FILE__),
-                                    '..', 'packet_data', name))
-  case File.extname(name)
-  when '.raw'
-    @raw = path
-  when '.pcap'
-    @pcap = path
-  else
-    fail "Unsupported file extension: #{name}"
+When(/^I try to create a packet with:$/) do |ruby_code|
+  begin
+    @result = Pio.module_eval(ruby_code)
+  rescue
+    @last_error = $ERROR_INFO
   end
 end
 
-When(/^I try to parse the file with "(.*?)" class$/) do |parser|
-  parser_klass = Pio.const_get(parser)
-  if @raw
-    @result = parser_klass.read(IO.read(@raw))
-  elsif @pcap
-    File.open(@pcap) do |file|
-      @result = []
-      pcap = Pio::Pcap::Frame.read(file)
-      pcap.records.each do |each|
-        @result << parser_klass.read(each.data)
-      end
-    end
-  else
-    fail 'Packet data file is not specified.'
+When(/^I try to create an OpenFlow message with:$/) do |ruby_code|
+  step 'I try to create a packet with:', ruby_code
+end
+
+# rubocop:disable LineLength
+When(/^I try to parse a file named "(.*?)\.raw" with "(.*?)" class$/) do |file_name, klass|
+  path = File.expand_path(File.join(__dir__, '..', 'packet_data', file_name + '.raw'))
+  raw_data = IO.read(path)
+  parser_klass = Pio.const_get(klass)
+  begin
+    @result = parser_klass.read(raw_data)
+  rescue
+    @last_error = $ERROR_INFO
   end
 end
+# rubocop:enable LineLength
 
-When(/^I try to create an exact match from the packet$/) do
-  @result = Pio::ExactMatch.new(Pio::PacketIn.read(IO.read(@raw)))
+# rubocop:disable LineLength
+When(/^I try to parse a file named "(.*?)\.pcap" with "(.*?)" class$/) do |file_name, klass|
+  path = File.expand_path(File.join(__dir__, '..', 'packet_data', file_name + '.pcap'))
+  pcap = Pio::Pcap::Frame.read(IO.read(path))
+  parser_klass = Pio.const_get(klass)
+  begin
+    @result = pcap.records.each_with_object([]) do |each, result|
+      result << parser_klass.read(each.data)
+    end
+  rescue
+    @last_error = $ERROR_INFO
+  end
 end
+# rubocop:enable LineLength
 
 Then(/^it should finish successfully$/) do
-  # Noop.
+  expect(@last_error).to be_nil
+end
+
+Then(/^it should fail with "([^"]*)", "([^"]*)"$/) do |error, message|
+  expect(@last_error.class.to_s).to eq(error)
+  expect(@last_error.message).to eq(message)
 end
 
-Then(/^the parsed data have the following field and value:$/) do |table|
+When(/^I create an exact match from "(.*?)"$/) do |file_name|
+  path = File.expand_path(File.join(__dir__, '..', 'packet_data', file_name))
+  @result = Pio::ExactMatch.new(Pio::PacketIn.read(IO.read(path)))
+end
+
+Then(/^the packet have the following fields and values:$/) do |table|
   table.hashes.each do |each|
     output = each['field'].split('.').inject(@result) do |memo, method|
       memo.__send__(method)
@@ -45,8 +61,12 @@ Then(/^the parsed data have the following field and value:$/) do |table|
   end
 end
 
+Then(/^the message have the following fields and values:$/) do |table|
+  step 'the packet have the following fields and values:', table
+end
+
 # rubocop:disable LineLength
-Then(/^the parsed data \#(\d+) have the following field and value:$/) do |index, table|
+Then(/^the message \#(\d+) have the following fields and values:$/) do |index, table|
   table.hashes.each do |each|
     output = each['field'].split('.').inject(@result[index.to_i - 1]) do |memo, method|
       memo.__send__(method)

data/features/support/env.rb

@@ -1,2 +1,5 @@
+require 'coveralls'
+Coveralls.wear!
+
 require 'pio'
 require 'pio/pcap'

data/features/{udp_read.feature → udp.feature}

@@ -1,9 +1,8 @@
-Feature: Pio::Udp.read
+Feature: UDP
   Scenario: dhcp.pcap
-    Given a packet data file "dhcp.pcap"
-    When I try to parse the file with "Udp" class
+    When I try to parse a file named "dhcp.pcap" with "Udp" class
     Then it should finish successfully
-    And the parsed data #1 have the following field and value:
+    And the message #1 have the following fields and values:
     | field                  |             value |
     | class                  |          Pio::Udp |
     | destination_mac        | ff:ff:ff:ff:ff:ff |

data/lib/pio.rb

@@ -7,6 +7,7 @@ require 'pio/exact_match'
 require 'pio/features'
 require 'pio/flow_mod'
 require 'pio/hello'
+require 'pio/hello13'
 require 'pio/icmp'
 require 'pio/lldp'
 require 'pio/mac'

data/lib/pio/echo.rb

@@ -1,3 +1,4 @@
+require 'forwardable'
 require 'pio/open_flow'
 
 module Pio
@@ -11,4 +12,70 @@ module Pio
     class Reply; end
     OpenFlow::Message.factory(Reply, OpenFlow::ECHO_REPLY)
   end
+
+  module Echo13
+    # Base class of Echo Request and Reply.
+    class Message
+      def self.message_name
+        name.split('::')[1..-1].map { |each| each.gsub(/\d+$/, '') }.join(' ')
+      end
+
+      def self.read(raw_data)
+        allocate.tap do |message|
+          message.instance_variable_set(:@format,
+                                        const_get(:Format).read(raw_data))
+        end
+      rescue BinData::ValidityError
+        raise Pio::ParseError, "Invalid #{message_name} 1.3 message."
+      end
+
+      def initialize(user_attrs = {})
+        unknown_attrs = user_attrs.keys - [:transaction_id, :xid, :body]
+        unless unknown_attrs.empty?
+          fail "Unknown keyword: #{unknown_attrs.first}"
+        end
+        header_options = OpenFlowHeader::Options.parse(user_attrs)
+        @format =
+          self.class.const_get(:Format).new(open_flow_header: header_options,
+                                            body: user_attrs[:body])
+      end
+
+      def method_missing(method, *args, &block)
+        @format.__send__ method, *args, &block
+      end
+    end
+
+    # Base class of Echo Request and Reply Format
+    class Format < BinData::Record
+      extend Forwardable
+
+      def_delegators :open_flow_header, :ofp_version
+      def_delegators :open_flow_header, :message_type
+      def_delegators :open_flow_header, :message_length
+      def_delegators :open_flow_header, :transaction_id
+      def_delegator :open_flow_header, :transaction_id, :xid
+    end
+
+    # OpenFlow 1.3 Echo Request message.
+    class Request < Message
+      # OpenFlow 1.3 Echo Request message format.
+      class Format < Echo13::Format
+        endian :big
+        open_flow_header :open_flow_header,
+                         ofp_version_value: 4, message_type_value: 2
+        string :body, read_length: -> { message_length - 8 }
+      end
+    end
+
+    # OpenFlow 1.3 Echo Reply message.
+    class Reply < Message
+      # OpenFlow 1.3 Echo Request message format.
+      class Format < Echo13::Format
+        endian :big
+        open_flow_header :open_flow_header,
+                         ofp_version_value: 4, message_type_value: 3
+        string :body, read_length: -> { message_length - 8 }
+      end
+    end
+  end
 end

data/lib/pio/hello13.rb

@@ -0,0 +1,111 @@
+require 'bindata'
+require 'forwardable'
+require 'pio/open_flow'
+require 'pio/parse_error'
+
+module Pio
+  # OpenFlow 1.3 Hello message parser and generator
+  class Hello13
+    # ofp_hello_elem_header and value
+    class Element < BinData::Record
+      VERSION_BITMAP = 1
+
+      endian :big
+
+      uint16 :element_type
+      uint16 :element_length
+      choice :element_value, selection: :chooser do
+        string 'unknown', read_length: -> { element_length - 4 }
+        uint32 'version_bitmap'
+      end
+
+      def version_bitmap?
+        element_type == VERSION_BITMAP
+      end
+
+      private
+
+      def chooser
+        version_bitmap? ? 'version_bitmap' : 'unknown'
+      end
+    end
+
+    # OpenFlow 1.3 Hello message body.
+    class Body < BinData::Record
+      array :elements, type: :element, read_until: :eof
+
+      def length
+        if elements.empty?
+          0
+        else
+          elements.length * 4 + 4
+        end
+      end
+    end
+
+    # OpenFlow 1.3 Hello message format
+    class Format < BinData::Record
+      extend Forwardable
+
+      endian :big
+
+      open_flow_header :open_flow_header,
+                       ofp_version_value: 4, message_type_value: 0
+      body :body
+
+      def_delegators :open_flow_header, :ofp_version
+      def_delegators :open_flow_header, :message_type
+      def_delegators :open_flow_header, :message_length
+      def_delegators :open_flow_header, :transaction_id
+      def_delegator :open_flow_header, :transaction_id, :xid
+      def_delegators :body, :elements
+
+      def supported_versions
+        supported_versions_list.map do |each|
+          "open_flow1#{each - 1}".to_sym
+        end
+      end
+
+      alias_method :to_binary, :to_binary_s
+
+      private
+
+      def supported_versions_list
+        (1..32).each_with_object([]) do |each, result|
+          result << each if (version_bitmap >> each & 1) == 1
+        end
+      end
+
+      def version_bitmap
+        bitmap = elements.find(&:version_bitmap?)
+        bitmap ? bitmap.element_value : 0
+      end
+    end
+
+    def self.read(raw_data)
+      allocate.tap do |message|
+        message.instance_variable_set(:@format, Format.read(raw_data))
+      end
+    rescue BinData::ValidityError
+      raise Pio::ParseError, 'Invalid Hello 1.3 message.'
+    end
+
+    def initialize(user_attrs = {})
+      unknown_keywords = user_attrs.keys - [:transaction_id, :xid]
+      unless unknown_keywords.empty?
+        fail "Unknown keyword: #{unknown_keywords.first}"
+      end
+
+      header_attrs = OpenFlowHeader::Options.parse(user_attrs)
+      body_attrs = { elements: [{ element_type: 1,
+                                  element_length: 8,
+                                  element_value: 16 }] }
+      @format = Format.new(open_flow_header: header_attrs,
+                           body: body_attrs)
+    end
+
+    def method_missing(method, *args, &block)
+      @format.__send__ method, *args, &block
+    end
+  end
+end

data/lib/pio/open_flow/message.rb

@@ -24,7 +24,8 @@ module Pio
             endian :big
 
             open_flow_header :open_flow_header,
-            message_type_value: #{message_type}
+                             ofp_version_value: 1,
+                             message_type_value: #{message_type}
             virtual assert: -> do
               open_flow_header.message_type == #{message_type}
             end

data/lib/pio/open_flow/open_flow_header.rb

@@ -1,46 +1,29 @@
 require 'bindata'
+require 'pio/open_flow/transaction_id'
 
 module Pio
-  # OpenFlow 1.0 format.
-  module OpenFlow
-    # OpenFlow 1.0 message header format.
-    class OpenFlowHeader < BinData::Record
-      # Transaction ID (uint32)
-      class TransactionId < BinData::Primitive
-        endian :big
-        uint32 :xid
+  # OpenFlow message header.
+  class OpenFlowHeader < BinData::Record
+    endian :big
 
-        def set(value)
-          unless value.unsigned_32bit?
-            fail(ArgumentError,
-                 'Transaction ID should be an unsigned 32-bit integer.')
-          end
-          self.xid = value
-        end
+    uint8 :ofp_version, value: :ofp_version_value
+    virtual assert: -> { ofp_version == ofp_version_value }
+    uint8 :message_type, value: :message_type_value
+    virtual assert: -> { message_type == message_type_value }
+    uint16 :message_length, initial_value: -> { 8 + body.length }
+    transaction_id :transaction_id, initial_value: 0
 
-        def get
-          xid
-        end
-      end
-
-      endian :big
-      uint8 :ofp_version, value: 1
-      uint8 :message_type, initial_value: :message_type_value
-      uint16 :message_length, initial_value: -> { 8 + body.length }
-      transaction_id :transaction_id, initial_value: 0
-
-      # parse header options
-      class Options
-        def self.parse(options)
-          xid = if options.respond_to?(:to_i)
-                  options.to_i
-                elsif options.respond_to?(:fetch)
-                  options[:transaction_id] || options[:xid] || 0
-                else
-                  fail TypeError
-                end
-          { transaction_id: xid }
-        end
+    # parse header options
+    class Options
+      def self.parse(options)
+        xid = if options.respond_to?(:to_i)
+                options.to_i
+              elsif options.respond_to?(:fetch)
+                options[:transaction_id] || options[:xid] || 0
+              else
+                fail TypeError
+              end
+        { transaction_id: xid }
       end
     end
   end

data/lib/pio/open_flow/transaction_id.rb

@@ -0,0 +1,25 @@
+require 'bindata'
+require 'pio/monkey_patch/integer'
+
+module Pio
+  module OpenFlow
+    # Transaction ID (uint32)
+    class TransactionId < BinData::Primitive
+      endian :big
+
+      uint32 :xid
+
+      def set(value)
+        unless value.unsigned_32bit?
+          fail(ArgumentError,
+               'Transaction ID should be an unsigned 32-bit integer.')
+        end
+        self.xid = value
+      end
+
+      def get
+        xid
+      end
+    end
+  end
+end

data/lib/pio/version.rb

@@ -1,5 +1,5 @@
 # Base module.
 module Pio
   # gem version.
-  VERSION = '0.18.2'.freeze
+  VERSION = '0.19.0'.freeze
 end