pio 0.10.1 → 0.11.0

data/features/packet_out_read.feature

@@ -3,3 +3,19 @@ Feature: Pio::PacketOut.read
     Given a packet data file "packet_out.raw"
     When I try to parse the file with "PacketOut" class
     Then it should finish successfully
+    And the parsed data have the following field and value:
+    | field                     |            value |
+    | class                     |   Pio::PacketOut |
+    | ofp_version               |                1 |
+    | message_type              |               13 |
+    | message_length            |               88 |
+    | transaction_id            |               22 |
+    | xid                       |               22 |
+    | buffer_id                 |       4294967295 |
+    | in_port                   |            65535 |
+    | actions.length            |                1 |
+    | actions.first.class       | Pio::SendOutPort |
+    | actions.first.port_number |                2 |
+    | actions.first.max_len     |            65535 |
+    | data.length               |               64 |
+

data/features/step_definitions/packet_data_steps.rb

@@ -14,7 +14,7 @@ end
 When(/^I try to parse the file with "(.*?)" class$/) do |parser|
   parser_klass = Pio.const_get(parser)
   if @raw
-    parser_klass.read IO.read(@raw)
+    @result = parser_klass.read(IO.read(@raw))
   elsif @pcap
     File.open(@pcap) do |file|
       pcap = Pio::Pcap::Frame.read(file)
@@ -28,3 +28,12 @@ end
 Then(/^it should finish successfully$/) do
   # Noop.
 end
+
+Then(/^the parsed data have the following field and value:$/) do |table|
+  table.hashes.each do |each|
+    output = each['field'].split('.').inject(@result) do |memo, method|
+      memo.__send__(method)
+    end
+    expect(output.to_s).to eq(each['value'])
+  end
+end

data/lib/pio.rb

@@ -4,6 +4,7 @@ require 'pio/arp'
 require 'pio/dhcp'
 require 'pio/echo'
 require 'pio/features'
+require 'pio/flow_mod'
 require 'pio/hello'
 require 'pio/icmp'
 require 'pio/lldp'

data/lib/pio/echo.rb

@@ -1,14 +1,16 @@
-require 'pio/echo/reply'
-require 'pio/echo/request'
 require 'pio/open_flow'
-require 'pio/open_flow/parser'
 
 module Pio
-  # OpenFlow 1.0 Echo Request and Reply message parser.
-  class Echo
-    KLASS = { Pio::OpenFlow::Type::ECHO_REQUEST => Pio::Echo::Request,
-              Pio::OpenFlow::Type::ECHO_REPLY => Pio::Echo::Reply }
+  # OpenFlow 1.0 Echo Request and Reply message.
+  module Echo
+    # @!parse
+    #   # OpenFlow 1.0 Echo Request message.
+    #   class Request < OpenFlow::Message; end
+    class Request < OpenFlow::Message.factory(OpenFlow::Type::ECHO_REQUEST); end
 
-    extend Pio::OpenFlow::Parser
+    # @!parse
+    #   # OpenFlow 1.0 Echo Reply message.
+    #   class Reply < OpenFlow::Message; end
+    class Reply < OpenFlow::Message.factory(OpenFlow::Type::ECHO_REPLY); end
   end
 end

data/lib/pio/enqueue.rb

@@ -1,7 +1,7 @@
 require 'bindata'
 require 'forwardable'
 require 'pio/monkey_patch/integer'
-require 'pio/open_flow'
+require 'pio/open_flow/port_number'
 
 module Pio
   # An action to enqueue the packet on the specified queue attached to

data/lib/pio/features.rb

@@ -1,14 +1,71 @@
-require 'pio/features/reply'
-require 'pio/features/request'
 require 'pio/open_flow'
-require 'pio/open_flow/parser'
 
 module Pio
-  # OpenFlow 1.0 Features Request and Reply message parser.
+  # OpenFlow 1.0 Features Request and Reply message.
   class Features
-    KLASS = { Pio::OpenFlow::Type::FEATURES_REQUEST => Pio::Features::Request,
-              Pio::OpenFlow::Type::FEATURES_REPLY => Pio::Features::Reply }
+    # OpenFlow 1.0 Features Request message.
+    class Request < OpenFlow::Message.factory(OpenFlow::Type::FEATURES_REQUEST)
+    end
 
-    extend Pio::OpenFlow::Parser
+    # OpenFlow 1.0 Features Reply message
+    class Reply < OpenFlow::Message.factory(OpenFlow::Type::FEATURES_REPLY)
+      # Message body of features reply.
+      class ReplyBody < BinData::Record
+        extend Flags
+
+        # enum ofp_capabilities
+        flags_32bit :capabilities,
+                    [:flow_stats,
+                     :table_stats,
+                     :port_stats,
+                     :stp,
+                     :reserved,
+                     :ip_reasm,
+                     :queue_stats,
+                     :arp_match_ip]
+
+        # enum ofp_action_type
+        flags_32bit :actions_flag,
+                    [:output,
+                     :set_vlan_vid,
+                     :set_vlan_pcp,
+                     :strip_vlan,
+                     :set_dl_src,
+                     :set_dl_dst,
+                     :set_nw_src,
+                     :set_nw_dst,
+                     :set_nw_tos,
+                     :set_tp_src,
+                     :set_tp_dst,
+                     :enqueue]
+
+        endian :big
+
+        uint64 :datapath_id
+        uint32 :n_buffers
+        uint8 :n_tables
+        uint24 :padding
+        hide :padding
+        capabilities :capabilities
+        actions_flag :actions
+        array :ports, type: :phy_port, read_until: :eof
+
+        def empty?
+          false
+        end
+
+        def length
+          24 + ports.to_binary_s.length
+        end
+      end
+
+      def_delegators :body, :datapath_id
+      def_delegator :body, :datapath_id, :dpid
+      def_delegators :body, :n_buffers
+      def_delegators :body, :n_tables
+      def_delegators :body, :capabilities
+      def_delegators :body, :actions
+      def_delegators :body, :ports
+    end
   end
 end

data/lib/pio/flow_mod.rb

@@ -0,0 +1,86 @@
+require 'pio/match'
+require 'pio/open_flow'
+
+module Pio
+  # OpenFlow 1.0 flow setup and teardown message.
+  class FlowMod < OpenFlow::Message.factory(OpenFlow::Type::FLOW_MOD)
+    # enum ofp_flow_mod_command
+    class Command < BinData::Primitive
+      COMMANDS = {
+        add: 0,
+        modify: 1,
+        modify_strict: 2,
+        delete: 3,
+        delete_strict: 4
+      }
+
+      endian :big
+      uint16 :command
+
+      def get
+        COMMANDS.invert.fetch(command)
+      end
+
+      def set(value)
+        self.command = COMMANDS.fetch(value)
+      end
+    end
+
+    # Message body of FlowMod.
+    class FlowModBody < BinData::Record
+      # Pio::MatchFormat wrapper.
+      class Match < BinData::Primitive
+        endian :big
+
+        string :match, read_length: 40
+
+        def set(object)
+          self.match = object.to_binary_s
+        end
+
+        def get
+          Pio::Match.read match
+        end
+      end
+
+      extend Flags
+
+      flags_16bit :flags,
+                  [:send_flow_rem,
+                   :check_overwrap,
+                   :emerg]
+
+      endian :big
+
+      match :match
+      uint64 :cookie
+      command :command
+      uint16 :idle_timeout
+      uint16 :hard_timeout
+      uint16 :priority
+      uint32 :buffer_id
+      uint16 :out_port
+      flags :flags
+      actions :actions, length: -> { open_flow_header.message_length - 72 }
+
+      def empty?
+        false
+      end
+
+      def length
+        64 + actions.binary.length
+      end
+    end
+
+    def_delegators :body, :match
+    def_delegators :body, :cookie
+    def_delegators :body, :command
+    def_delegators :body, :idle_timeout
+    def_delegators :body, :hard_timeout
+    def_delegators :body, :priority
+    def_delegators :body, :buffer_id
+    def_delegators :body, :out_port
+    def_delegators :body, :flags
+    def_delegators :body, :actions
+  end
+end

data/lib/pio/hello.rb

@@ -1,78 +1,8 @@
-require 'English'
-require 'bindata'
 require 'pio/open_flow'
-require 'pio/parse_error'
 
 module Pio
-  # OpenFlow 1.0 Hello message
-  class Hello < Pio::OpenFlow::Message
-    # Message body of Hello
-    class Body < BinData::Record
-      endian :big
-
-      string :body # ignored
-
-      def length
-        0
-      end
-
-      def empty?
-        true
-      end
-    end
-
-    def_format Pio::OpenFlow::Type::HELLO
-
-    # Parses +raw_data+ binary string into a Hello message object.
-    #
-    # @example
-    #   Pio::Hello.read("\x01\x00\x00\b\x00\x00\x00\x00")
-    # @return [Pio::Hello]
-    def self.read(raw_data)
-      hello = allocate
-      hello.instance_variable_set :@format, Format.read(raw_data)
-      hello
-    rescue BinData::ValidityError
-      raise Pio::ParseError, $ERROR_INFO.message
-    end
-
-    # Creates a Hello OpenFlow message.
-    #
-    # @overload initialize()
-    #   @example
-    #     Pio::Hello.new
-    #
-    # @overload initialize(transaction_id)
-    #   @example
-    #     Pio::Hello.new(123)
-    #   @param [Number] transaction_id
-    #     An unsigned 32-bit integer number associated with this
-    #     message.
-    #
-    # @overload initialize(user_options)
-    #   @example
-    #     Pio::Hello.new(transaction_id: 123)
-    #     Pio::Hello.new(xid: 123)
-    #   @param [Hash] user_options The options to create a message with.
-    #   @option user_options [Number] :transaction_id
-    #   @option user_options [Number] :xid An alias to transaction_id.
-    #
-    # @reek This method smells of :reek:FeatureEnvy
-    # rubocop:disable MethodLength
-    def initialize(user_options = {})
-      options = if user_options.respond_to?(:to_i)
-                  { transaction_id: user_options.to_i }
-                elsif user_options.respond_to?(:fetch)
-                  { transaction_id: user_options[:transaction_id] ||
-                                    user_options[:xid] || 0 }
-                else
-                  fail TypeError
-                end
-      if options[:transaction_id] >= 2**32
-        fail ArgumentError, 'Transaction ID >= 2**32'
-      end
-      @format = Format.new(open_flow_header: options)
-    end
-    # rubocop:enable MethodLength
-  end
+  # @!parse
+  #   # OpenFlow 1.0 Hello message
+  #   class Hello < OpenFlow::Message; end
+  class Hello < OpenFlow::Message.factory(Pio::OpenFlow::Type::HELLO); end
 end

data/lib/pio/ipv4_address.rb

@@ -29,7 +29,7 @@ module Pio
       when IPv4Address
         @value = addr.value
       else
-        fail TypeError, "Invalid IPv4 address: #{ addr.inspect }"
+        fail TypeError, "Invalid IPv4 address: #{addr.inspect}"
       end
     end
 

data/lib/pio/match.rb

@@ -0,0 +1,167 @@
+require 'English'
+require 'bindata'
+require 'pio/open_flow'
+require 'pio/type/ip_address'
+require 'pio/type/mac_address'
+require 'forwardable'
+
+module Pio
+  # Fields to match against flows
+  class Match
+    # Flow wildcards
+    class Wildcards < BinData::Primitive
+      BITS = {
+        in_port: 1 << 0,
+        dl_vlan: 1 << 1,
+        dl_src: 1 << 2,
+        dl_dst: 1 << 3,
+        dl_type: 1 << 4,
+        nw_proto: 1 << 5,
+        tp_src: 1 << 6,
+        tp_dst: 1 << 7,
+        nw_src: 0,
+        nw_src0: 1 << 8,
+        nw_src1: 1 << 9,
+        nw_src2: 1 << 10,
+        nw_src3: 1 << 11,
+        nw_src4: 1 << 12,
+        nw_src_all: 1 << 13,
+        nw_dst: 0,
+        nw_dst0: 1 << 14,
+        nw_dst1: 1 << 15,
+        nw_dst2: 1 << 16,
+        nw_dst3: 1 << 17,
+        nw_dst4: 1 << 18,
+        nw_dst_all: 1 << 19,
+        dl_vlan_pcp: 1 << 20,
+        nw_tos: 1 << 21
+      }
+      NW_FLAGS = [:nw_src, :nw_dst]
+      FLAGS = BITS.keys.select { |each| !(/^nw_(src|dst)/=~ each) }
+
+      endian :big
+
+      uint32 :flags
+
+      # This method smells of :reek:FeatureEnvy
+      def get
+        BITS.each_with_object(Hash.new(0)) do |(key, bit), memo|
+          next if flags & bit == 0
+          if /(nw_src|nw_dst)(\d)/=~ key
+            memo[$LAST_MATCH_INFO[1].intern] |= 1 << $LAST_MATCH_INFO[2].to_i
+          else
+            memo[key] = true
+          end
+        end
+      end
+
+      def set(params)
+        self.flags = params.inject(0) do |memo, (key, val)|
+          memo | case key
+                 when :nw_src, :nw_dst
+                   (params.fetch(key) & 31) << (key == :nw_src ? 8 : 14)
+                 else
+                   val ? BITS.fetch(key) : 0
+                 end
+        end
+      end
+
+      def nw_src
+        get.fetch(:nw_src)
+      rescue KeyError
+        0
+      end
+
+      def nw_dst
+        get.fetch(:nw_dst)
+      rescue KeyError
+        0
+      end
+    end
+
+    # IP address
+    class MatchIpAddress < BinData::Primitive
+      default_parameter bitcount: 0
+
+      array :octets, type: :uint8, initial_length: 4
+
+      def set(value)
+        self.octets = IPv4Address.new(value).to_a
+      end
+
+      def get
+        ipaddr = octets.map { |each| format('%d', each) }.join('.')
+        prefixlen = 32 - eval_parameter(:bitcount)
+        IPv4Address.new(ipaddr + "/#{prefixlen}")
+      end
+
+      def ==(other)
+        get == other
+      end
+    end
+
+    # ofp_match format
+    class MatchFormat < BinData::Record
+      endian :big
+
+      wildcards :wildcards
+      uint16 :in_port
+      mac_address :dl_src
+      mac_address :dl_dst
+      uint16 :dl_vlan
+      uint8 :dl_vlan_pcp
+      uint8 :padding1
+      hide :padding1
+      uint16 :dl_type
+      uint8 :nw_tos
+      uint8 :nw_proto
+      uint16 :padding2
+      hide :padding2
+      match_ip_address :nw_src, bitcount: -> { wildcards.nw_src }
+      match_ip_address :nw_dst, bitcount: -> { wildcards.nw_dst }
+      uint16 :tp_src
+      uint16 :tp_dst
+    end
+
+    def self.read(binary)
+      MatchFormat.read binary
+    end
+
+    extend Forwardable
+
+    def_delegators :@format, :wildcards
+    def_delegators :@format, :in_port
+    def_delegators :@format, :dl_vlan
+    def_delegators :@format, :dl_src
+    def_delegators :@format, :dl_dst
+    def_delegators :@format, :dl_type
+    def_delegators :@format, :nw_proto
+    def_delegators :@format, :tp_src
+    def_delegators :@format, :tp_dst
+    def_delegators :@format, :nw_src
+    def_delegators :@format, :nw_src_all
+    def_delegators :@format, :nw_dst
+    def_delegators :@format, :nw_dst_all
+    def_delegators :@format, :dl_vlan_pcp
+    def_delegators :@format, :nw_tos
+    def_delegators :@format, :to_binary_s
+
+    # rubocop:disable MethodLength
+    # This method smells of :reek:FeatureEnvy
+    # This method smells of :reek:DuplicateMethodCall
+    def initialize(user_options)
+      flags = Wildcards::FLAGS.each_with_object({}) do |each, memo|
+        memo[each] = true unless user_options.key?(each)
+      end
+      Wildcards::NW_FLAGS.each_with_object(flags) do |each, memo|
+        if user_options.key?(each)
+          memo[each] = 32 - IPv4Address.new(user_options[each]).prefixlen
+        else
+          memo["#{each}_all".intern] = true
+        end
+      end
+      @format = MatchFormat.new({ wildcards: flags }.merge user_options)
+    end
+    # rubocop:enable MethodLength
+  end
+end