pio 0.1.1 → 0.2.1

data/lib/pio/ip.rb

@@ -0,0 +1,90 @@
+module Pio
+  #
+  # A wrapper class to IPAddr
+  #
+  class IP
+    require "ipaddr"
+
+
+    #
+    # @return [IPAddr] value object instance of proxied IPAddr.
+    #
+    attr_reader :value
+
+
+    attr_reader :prefixlen
+
+
+    #
+    # Creates a {IP} instance object as a proxy to IPAddr class.
+    #
+    # @overload initialize(addr)
+    #
+    # @param [String, Number] addr
+    #   an IPv4 address specified either as a String or Number.
+    #
+    # @param [Number] prefixlen
+    #   masking IPv4 address with given prefixlen.
+    #
+    # @raise [ArgumentError] invalid address if supplied argument is invalid
+    #   IPv4 address.
+    #
+    # @return [IP] self
+    #   a proxy to IPAddr.
+    #
+    def initialize addr, prefixlen = 32
+      @prefixlen = prefixlen
+      case addr
+      when Integer
+        @value = IPAddr.new( addr, Socket::AF_INET )
+      when String
+        @value = IPAddr.new( addr )
+      else
+        raise TypeError, "Invalid IP address: #{ addr.inspect }"
+      end
+      if prefixlen < 32
+        @value = @value.mask( prefixlen )
+      end
+    end
+
+
+    #
+    # @return [String] the IPv4 address in its text representation.
+    #
+    def to_s
+      @value.to_s
+    end
+
+
+    #
+    # @return [Number] the IPv4 address in its numeric representation.
+    #
+    def to_i
+      @value.to_i
+    end
+
+
+    def == other
+      to_s == other.to_s
+    end
+
+
+    #
+    # @return [Array]
+    #    an array of decimal numbers converted from IP address.
+    #
+    def to_a
+      to_s.split( "." ).collect do | each |
+        each.to_i
+      end
+    end
+    alias :to_array :to_a
+  end
+end
+
+
+### Local variables:
+### mode: Ruby
+### coding: utf-8-unix
+### indent-tabs-mode: nil
+### End:

data/lib/pio/lldp.rb

@@ -1,6 +1,3 @@
-require "rubygems"
-
-require "bindata"
 require "forwardable"
 require "pio/lldp/frame"
 
@@ -8,27 +5,92 @@ require "pio/lldp/frame"
 module Pio
   # LLDP frame parser and generator.
   class Lldp
+    # User options for creating an LLDP frame.
+    class Options
+      def initialize options
+        @options = options
+
+        unless dpid
+          raise TypeError, "Invalid DPID: #{ dpid.inspect }"
+        end
+        unless port_id
+          raise TypeError, "Invalid port number: #{ port_id.inspect }"
+        end
+      end
+
+
+      def to_hash
+        {
+          :destination_mac => Mac.new( destination_mac ).to_a,
+          :source_mac => Mac.new( source_mac ).to_a,
+          :chassis_id => dpid,
+          :port_id => port_id
+        }
+      end
+
+
+      ##########################################################################
+      private
+      ##########################################################################
+
+
+      def dpid
+        @options[ :dpid ]
+      end
+
+
+      def port_id
+        @options[ :port_number ]
+      end
+
+
+      def destination_mac
+        @options[ :destination_mac ] || "01:80:c2:00:00:0e"
+      end
+
+
+      def source_mac
+        @options[ :source_mac ] || "01:02:03:04:05:06"
+      end
+    end
+
+
     extend Forwardable
 
 
     def self.read raw_data
-      frame = Frame.read( raw_data )
-      new frame.dpid, frame.port_id
+      begin
+        frame = Frame.read( raw_data )
+      rescue
+        raise Pio::ParseError, $!.message
+      end
+      lldp = allocate
+      lldp.instance_variable_set :@frame, frame
+      lldp
     end
 
 
-    def initialize dpid, port_number, destination_mac = "01:80:c2:00:00:0e"
-      @frame = Frame.new
-      @frame.destination_mac = destination_mac
-      @frame.source_mac = "11:22:33:44:55:66"  # FIXME
-      @frame.chassis_id = dpid
-      @frame.port_id = port_number
+    def initialize options
+      @frame = Frame.new( Options.new( options ).to_hash )
     end
 
 
+    def_delegator :@frame, :destination_mac
+    def_delegator :@frame, :source_mac
+    def_delegator :@frame, :ether_type
+    def_delegator :@frame, :chassis_id
     def_delegator :@frame, :dpid
     def_delegator :@frame, :optional_tlv
-    def_delegator :@frame, :port_id, :port_number
+    def_delegator :@frame, :port_id
+    alias :port_number :port_id
+    def_delegator :@frame, :ttl
+    def_delegator :@frame, :port_description
+    def_delegator :@frame, :system_name
+    def_delegator :@frame, :system_description
+    def_delegator :@frame, :system_capabilities
+    def_delegator :@frame, :enabled_capabilities
+    def_delegator :@frame, :management_address
+    def_delegator :@frame, :organizationally_specific
 
 
     def to_binary

data/lib/pio/lldp/frame.rb

@@ -2,21 +2,21 @@ require "rubygems"
 require "bindata"
 
 require "pio/lldp/chassis-id-tlv"
-require "pio/lldp/mac-address"
 require "pio/lldp/optional-tlv"
 require "pio/lldp/port-id-tlv"
 require "pio/lldp/ttl-tlv"
+require "pio/type/ethernet-header"
 
 
 module Pio
   class Lldp
     # LLDP frame
     class Frame < BinData::Record
+      extend Type::EthernetHeader
+
       endian :big
 
-      mac_address :destination_mac
-      mac_address :source_mac
-      uint16 :ethertype, :value => 0x88cc
+      ethernet_header :ether_type => 0x88cc
       chassis_id_tlv :chassis_id
       port_id_tlv :port_id
       ttl_tlv :ttl, :initial_value => 120
@@ -26,6 +26,55 @@ module Pio
       def dpid
         chassis_id
       end
+
+
+      def port_description
+        get_tlv_field 4, "port_description"
+      end
+
+
+      def system_name
+        get_tlv_field 5, "system_name"
+      end
+
+
+      def system_description
+        get_tlv_field 6, "system_description"
+      end
+
+
+      def system_capabilities
+        get_tlv 7
+      end
+
+
+      def management_address
+        get_tlv_field 8, "management_address"
+      end
+
+
+      def organizationally_specific
+        get_tlv 127
+      end
+
+
+      ##########################################################################
+      private
+      ##########################################################################
+
+
+      def get_tlv tlv_type
+        tlv = optional_tlv.find do | each |
+          each[ "tlv_type" ] == tlv_type
+        end
+        tlv[ "tlv_value" ] if tlv
+      end
+
+
+      def get_tlv_field tlv_type, name
+        tlv = get_tlv( tlv_type )
+        tlv[ name ] if tlv
+      end
     end
   end
 end

data/lib/pio/lldp/management-address-value.rb

@@ -8,7 +8,13 @@ module Pio
     class ManagementAddressValue < BinData::Record
       endian :big
 
-      stringz :management_address
+      uint8 :string_length
+      uint8 :subtype
+      string :management_address, :read_length => lambda { string_length - 1 }
+      uint8 :interface_numbering_subtype
+      uint32 :interface_number
+      uint8 :oid_string_length
+      string :object_identifier, :read_length => lambda { oid_string_length }
     end
   end
 end

data/lib/pio/lldp/optional-tlv.rb

@@ -3,6 +3,7 @@ require "pio/lldp/system-name-value"
 require "pio/lldp/system-description-value"
 require "pio/lldp/system-capabilities-value"
 require "pio/lldp/management-address-value"
+require "pio/lldp/organizationally-specific-value"
 require "pio/lldp/end-of-lldpdu-value"
 
 
@@ -24,6 +25,7 @@ module Pio
         system_description_value 6
         system_capabilities_value 7
         management_address_value 8
+        organizationally_specific_value 127
         string "unknown"
       end
 
@@ -54,7 +56,7 @@ module Pio
 
       def optional_tlv?
         tmp_tlv_type = tlv_type
-        4 <= tmp_tlv_type and tmp_tlv_type <= 8
+        4 <= tmp_tlv_type and tmp_tlv_type <= 127
       end
 
 

data/lib/pio/lldp/organizationally-specific-value.rb

@@ -0,0 +1,23 @@
+require "rubygems"
+require "bindata"
+
+
+module Pio
+  class Lldp
+    # The V of Organizationally specfic TLV.
+    class OrganizationallySpecificValue < BinData::Record
+      endian :big
+
+      uint24be :oui
+      uint8 :subtype
+      stringz :information
+    end
+  end
+end
+
+
+### Local variables:
+### mode: Ruby
+### coding: utf-8-unix
+### indent-tabs-mode: nil
+### End:

data/lib/pio/mac.rb

@@ -0,0 +1,156 @@
+require "forwardable"
+
+
+module Pio
+  #
+  # Ethernet address class
+  #
+  class Mac
+    extend Forwardable
+    def_delegator :@value, :hash
+
+
+    #
+    # Returns an Ethernet address in its numeric presentation.
+    #
+    # @example
+    #   Mac.new("11:22:33:44:55:66") #=> 18838586676582
+    #
+    # @return [Number] the Ethernet address in numeric format
+    #
+    attr_reader :value
+
+
+    #
+    # Creates a {Mac} instance that encapsulates Ethernet addresses.
+    #
+    # @overload initialize(value)
+    #
+    # @param [String,Integer] value
+    #   the Ethernet address to set to.
+    #
+    # @example address as a hexadecimal string
+    #   Mac.new("11:22:33:44:55:66")
+    #
+    # @example address as a hexadecimal number
+    #   Mac.new(0xffffffffffff)
+    #
+    # @raise [ArgumentError] if invalid format is detected.
+    # @raise [TypeError] if supplied argument is not a String or Integer.
+    #
+    def initialize value
+      case value
+        when String
+          @value = create_from( value )
+        when Integer
+          @value = value
+          validate_value_range
+        when Mac
+          @value = create_from( value.to_s )
+        else
+          raise TypeError, "Invalid MAC address: #{ value.inspect }"
+      end
+      @string = string_format
+    end
+
+
+    #
+    # Returns the Ethernet address as 6 pairs of hexadecimal digits
+    # delimited by colons.
+    #
+    # @example
+    #   Mac.new(18838586676582).to_s #=> "11:22:33:44:55:66"
+    #
+    # @return [String] the Ethernet address in String format
+    #
+    def to_s
+      @string
+    end
+
+
+    #
+    # Returns an array of decimal numbers converted from Ethernet's
+    # address string format.
+    #
+    # @example
+    #   Mac.new("11:22:33:44:55:66").to_a #=> [ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 ]
+    #
+    # @return [Array] the Ethernet address in Array format
+    #
+    def to_a
+      @string.split( ":" ).collect do | each |
+        each.hex
+      end
+    end
+
+
+    #
+    # @private
+    #
+    def == other
+      to_s == other.to_s
+    end
+    alias :eql? :==
+
+
+    #
+    # Returns true if Ethernet address is a multicast address.
+    #
+    # @example
+    #   Mac.new("01:00:00:00:00:00").multicast? #=> true
+    #   Mac.new("00:00:00:00:00:00").multicast? #=> false
+    #
+    # @return [Boolean] whether the Ethernet address is multicast
+    #
+    def multicast?
+      to_a[ 0 ] & 1 == 1
+    end
+
+
+    #
+    # Returns true if Ethernet address is a broadcast address.
+    #
+    # @example
+    #   Mac.new("ff:ff:ff:ff:ff:ff").broadcast? #=> true
+    #
+    # @return [Boolean] whether the Ethernet address is broadcast
+    #
+    def broadcast?
+      to_a.all? { | each | each == 0xff }
+    end
+
+
+    ################################################################################
+    private
+    ################################################################################
+
+
+    def create_from string
+      octet_regex = "[0-9a-fA-F][0-9a-fA-F]"
+      if /^(#{ octet_regex }:){5}(#{ octet_regex })$/=~ string
+        string.gsub( ":", "" ).hex
+      else
+        raise ArgumentError, %{Invalid MAC address: "#{ string }"}
+      end
+    end
+
+
+    def validate_value_range
+      unless ( @value >= 0 and @value <= 0xffffffffffff )
+        raise ArgumentError, "Invalid MAC address: #{ @value }"
+      end
+    end
+
+
+    def string_format
+      sprintf( "%012x", @value ).unpack( "a2" * 6 ).join( ":" )
+    end
+  end
+end
+
+
+### Local variables:
+### mode: Ruby
+### coding: utf-8-unix
+### indent-tabs-mode: nil
+### End: