ospfv2 0.0.1 → 0.0.2

data/lib/lsa/lsa_factory.rb

@@ -32,13 +32,15 @@ module OSPFv2
       def factory(arg)
         if arg.is_a?(String)
           return unless (arg.size>=20)
-          case arg[3]
+          case arg.slice(3,1).unpack('C')[0]
           when 1 ; OSPFv2::Router.new_ntop(arg)
           when 2 ; OSPFv2::Network.new_ntop(arg)
           when 3 ; OSPFv2::Summary.new_ntop(arg)
           when 4 ; OSPFv2::AsbrSummary.new_ntop(arg)
           when 5 ; OSPFv2::AsExternal.new_ntop(arg)
           when 7 ; OSPFv2::AsExternal7.new_ntop(arg)
+          else 
+            raise
           end
         elsif arg.is_a?(Hash)
           case arg[:ls_type]
@@ -48,6 +50,8 @@ module OSPFv2
           when :asbr_summary_lsa  ; OSPFv2::AsbrSummary.new_hash(arg)
           when :as_external_lsa   ; OSPFv2::AsExternal.new_hash(arg)
           when :as_external7_lsa  ; OSPFv2::AsExternal7.new_hash(arg)
+          else
+            raise
           end
         elsif arg.is_a?(Lsa)
           factory(arg.encode)

data/lib/lsa/network.rb

@@ -80,15 +80,20 @@ require 'ie/id'
 require 'lsa/lsa'
 module OSPFv2
   
-NetworkMask = Class.new(Id)
-AttachRouter = Class.new(Id)
+  
 
 class Network < Lsa
   
+  unless const_defined?(:NetworkMask)
+    NetworkMask = Class.new(Id)
+    AttachRouter = Class.new(Id)
+  end
+  
   attr_reader :network_mask, :attached_routers
   
   def initialize(arg={})
     @network_mask, @attached_routers = nil, []
+    @ls_type = LsType.new(:network_lsa)
     super
   end
   

data/lib/lsa/opaque.rb

@@ -0,0 +1,143 @@
+# A.2.  The Opaque LSA
+# 
+#    Opaque LSAs are Type 9, 10, and 11 link state advertisements.  These
+#    advertisements MAY be used directly by OSPF or indirectly by some
+#    application wishing to distribute information throughout the OSPF
+#    domain.  The function of the Opaque LSA option is to provide for
+#    future OSPF extensibility.
+# 
+#    Opaque LSAs contain some number of octets (of application-specific
+#    data) padded to 32-bit alignment.  Like any other LSA, the Opaque LSA
+#    uses the link-state database distribution mechanism for flooding this
+#    information throughout the topology.  However, the Opaque LSA has a
+#    flooding scope associated with it so that the scope of flooding may
+#    be link-local (type-9), area-local (type-10), or the entire OSPF
+#    routing domain (type-11).  Section 3 of this document describes the
+#    flooding procedures for the Opaque LSA.
+# 
+# 
+# 
+# 
+# 
+# 
+# 
+# 
+# 
+# Berger, et al.              Standards Track                    [Page 14]
+# 
+# RFC 5250                 OSPF Opaque LSA Option                July 2008
+# 
+# 
+#        0                   1                   2                   3
+#        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+#       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#       |            LS age             |     Options   |  9, 10, or 11 |
+#       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#       |  Opaque Type  |               Opaque ID                       |
+#       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#       |                      Advertising Router                       |
+#       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#       |                      LS Sequence Number                       |
+#       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#       |         LS checksum           |           Length              |
+#       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#       |                                                               |
+#       +                                                               +
+#       |                      Opaque Information                       |
+#       +                                                               +
+#       |                              ...                              |
+# 
+#    Link-State Type
+# 
+#       The link-state type of the Opaque LSA identifies the LSA's range
+#       of topological distribution.  This range is referred to as the
+#       flooding scope.  The following explains the flooding scope of each
+#       of the link-state types.
+# 
+#       o  A value of 9 denotes a link-local scope.  Opaque LSAs with a
+#          link-local scope MUST NOT be flooded beyond the local
+#          (sub)network.
+# 
+#       o  A value of 10 denotes an area-local scope.  Opaque LSAs with an
+#          area-local scope MUST NOT be flooded beyond their area of
+#          origin.
+# 
+#       o  A value of 11 denotes that the LSA is flooded throughout the
+#          Autonomous System (e.g., has the same scope as type-5 LSAs).
+#          Opaque LSAs with AS-wide scope MUST NOT be flooded into stub
+#          areas or NSSAs.
+# 
+#    Syntax of the Opaque LSA's Link-State ID
+# 
+#       The link-state ID of the Opaque LSA is divided into an Opaque Type
+#       field (the first 8 bits) and an Opaque ID (the remaining 24 bits).
+#       See section 7 of this document for a description of Opaque type
+#       allocation and assignment.
+# 
+# 
+
+module OSPFv2
+  class Opaque_Base < Lsa
+  end
+end
+
+__END__
+
+
+3.  The Opaque LSA
+
+   Opaque LSAs are types 9, 10, and 11 link state advertisements.
+   Opaque LSAs consist of a standard LSA header followed by a 32-bit
+   aligned application-specific information field.  Standard link-state
+   database flooding mechanisms are used for distribution of Opaque
+   LSAs.  The range of topological distribution (i.e., the flooding
+   scope) of an Opaque LSA is identified by its link-state type.  This
+   section documents the flooding of Opaque LSAs.
+
+   The flooding scope associated with each Opaque link-state type is
+   defined as follows.
+
+   o  Link-state type-9 denotes a link-local scope.  Type-9 Opaque LSAs
+      are not flooded beyond the local (sub)network.
+
+   o  Link-state type-10 denotes an area-local scope.  Type-10 Opaque
+      LSAs are not flooded beyond the borders of their associated area.
+
+   o  Link-state type-11 denotes that the LSA is flooded throughout the
+      Autonomous System (AS).  The flooding scope of type-11 LSAs are
+      equivalent to the flooding scope of AS-External (type-5) LSAs.
+      Specifically, type-11 Opaque LSAs are 1) flooded throughout all
+      transit areas, 2) not flooded into stub areas or Not-So-Stubby
+      Areas (NSSAs), see [NSSA], from the backbone, and 3) not
+      originated by routers into their connected stub areas or NSSAs.
+      As with type-5 LSAs, if a type-11 Opaque LSA is received in a stub
+      area or NSSA from a neighboring router within the stub area or
+      NSSA, the LSA is rejected.
+
+   The link-state ID of the Opaque LSA is divided into an Opaque type
+   field (the first 8 bits) and a type-specific ID (the remaining 24
+   bits).  The packet format of the Opaque LSA is given in Appendix A.
+   Section 7 describes Opaque type allocation and assignment.
+
+   The responsibility for proper handling of the Opaque LSA's flooding
+   scope is placed on both the sender and receiver of the LSA.  The
+   receiver must always store a valid received Opaque LSA in its link-
+   state database.  The receiver must not accept Opaque LSAs that
+   violate the flooding scope (e.g., a type-11 (domain-wide) Opaque LSA
+
+
+
+
+
+Berger, et al.              Standards Track                     [Page 4]
+
+RFC 5250                 OSPF Opaque LSA Option                July 2008
+
+
+   is not accepted in a stub area or NSSA).  The flooding scope affects
+   both the synchronization of the link-state database and the flooding
+   procedure.
+
+   The following describes the modifications to these procedures that
+   are necessary to insure conformance to the Opaque LSA's Scoping
+   Rules.

data/lib/lsa/router.rb

@@ -205,8 +205,10 @@ module OSPFv2
       super
       @links=[]
       @nwveb ||=0
+      @ls_type = LsType.new(:router_lsa)
+      
       # arg.merge!({:ls_type => 1}) if arg.is_a?(Hash)
-      [[:abr,1],[:asbr,2],[:vl,4],[:wild,8],[:nssa,16]].each { |x| def_bit *x }
+      [[:abr,1],[:asbr,2],[:vl,4],[:wild,8],[:nssa,16]].each { |x| def_bit(*x) } unless respond_to? :set_abr
     end
     
     # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -239,21 +241,21 @@ module OSPFv2
         self << links.slice!(0,12+ntos*4)
       end
     end
-    
+
     def to_s_default
-       super  +
-       ['', nwveb_to_s, *links.collect {|x| x.to_s6 }].join("\n   ")
-     end
+      super  +
+      ['', nwveb_to_s, *links.collect {|x| x.to_s }].join("\n   ")
+    end
 
-     def to_s_junos
-       super
-     end
+    def to_s_junos
+      super
+    end
 
-     def to_s_junos_verbose
-       link_hdr = "  bits 0x#{nwveb.to_i}, link count #{links.size}"
-       links_to_s = links.collect {|link| link.to_s_junos }
-       super + ['', link_hdr, *links_to_s].join("\n")
-     end
+    def to_s_junos_verbose
+      link_hdr = "  bits 0x#{nwveb.to_i}, link count #{links.size}"
+      links_to_s = links.collect {|link| link.to_s_junos }
+      super + ['', link_hdr, *links_to_s].join("\n")
+    end
 
     def has_link?(*args)
       self[*args] ? true : false
@@ -279,7 +281,7 @@ module OSPFv2
       links.each { |x| yield(x)  }
     end
     
-    #FIXME: make link_id an integer ...
+    #FIXME: make link_id an integer ... 
     def args_to_key(*args)
       if args.size==1 and args[0].is_a?(RouterLink)
         [args[0].router_link_type.to_i, args[0].link_id.to_hash]
@@ -311,17 +313,7 @@ module OSPFv2
     end
 
   end
-  
-  # 
-  # rlsa = Router.new( :advertising_router => '1.1.1.1', :ls_id => '2.2.2.2')
-  # p rlsa.advertising_router
-  # p rlsa.ls_id
-  # 
-  # $style=:default
-  # 
-  # puts rlsa
-
-  
+    
   class Router
     def self.new_hash(h)
       r = new(h)

data/lib/lsa/summary.rb

@@ -26,31 +26,25 @@ require 'ie/metric'
 require 'ie/mt_metric'
 require 'ie/id'
 
-
 module OSPFv2
 
-  Netmask = Class.new(Id)
+  unless const_defined?(:Netmask)
+    Netmask = Class.new(Id)
+  end
   
   class Summary_Base < Lsa
+    include CommonMetric
     
     attr_reader :metric, :netmask, :mt_metrics
     
-    def initialize(arg={})
+    def initialize(type, arg={})
       @netmask=nil
       @metric=nil
       @mt_metrics=[]
-      super
+      @ls_type = LsType.new(type)
+      super arg
     end
     
-    def mt_metrics=(val)
-      [val].flatten.each { |x| self << x }
-    end
-    
-    def <<(metric)
-      @mt_metrics ||=[]
-      @mt_metrics << MtMetric.new(metric)
-    end
-
     def encode
       @netmask ||= Netmask.new
       @metric  ||= Metric.new
@@ -121,15 +115,17 @@ module OSPFv2
     
     
     def initialize(arg={})
-      if arg.is_a?(Hash)
-        arg = fix_hash(arg).merge!({:ls_type => :summary_lsa,}) 
+      case arg
+      when Hash
+        arg = fix_hash(arg).merge!({:ls_type => :summary_lsa,})
       end
-      super
+      super 3, arg
     end
     
     private
     
     def fix_hash(arg)
+      
       if arg[:network]
         addr = IPAddr.new arg[:network]
         arg.delete :network
@@ -137,14 +133,17 @@ module OSPFv2
         arg.store :ls_id, addr.to_s
       end
       arg
+    rescue => e
+      p 'HERE'
+      p arg
+      raise
     end
     
   end
   
   class AsbrSummary < Summary_Base
     def initialize(arg={})
-      arg.merge!({:ls_type => :asbr_summary_lsa,}) if arg.is_a?(Hash)
-      super
+      super 4, arg
     end
   end
   
@@ -162,17 +161,6 @@ load "../../../test/ospfv2/lsa/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if
 
 __END__
 
-# if arg.is_a?(Hash)
-#   arg.merge!({:ls_type=> :summary_lsa}) unless arg.has_key?(:ls_type) 
-#   set arg
-#    super
-# elsif arg.is_a?(String)
-#   parse arg
-# elsif arg.is_a?(self.class)
-#   parse arg.encode
-# else
-#   raise ArgumentError, "Invalid argument", caller
-# end
 
 =begin rdoc
 
@@ -249,145 +237,3 @@ A.4.4 Summary-LSAs
 
 
 =end
-
-
-module Ospf
-  module Summary_Shared
-    private
-    def __to_s_junos_style__(sum_type, rtype=' ')
-      enc
-      s = @header.to_s_junos_style(sum_type,rtype)
-      s +="\n  mask #{netmask}"
-      s +="\n  Topology default (ID #{@mt_id[0].id}) -> Metric: #{@mt_id[0].metric}"
-      s += @mt_id[1..-1].collect { |mt| "\n  #{mt.to_s_junos_style}" }.join
-      s
-    end
-    def __to_hash__(sum_type)
-      enc
-      h = @header.to_hash.merge({:lsa_type=>sum_type, :netmask => netmask,})
-      if @mt_id.size > 1 or @mt_id[0].id != 0
-        h[:mt_id] = @mt_id.collect { |mt_id| mt_id.to_hash } unless @mt_id.nil?
-      else
-        h[:metric] = @mt_id[0].metric
-      end
-      h
-    end
-    private :__to_s_junos_style__, :__to_hash__
-    
-  end
-end
-
-require 'lsa_header'
-  
-module Ospf
-
-  class SummaryLSAs < LSA
-    include Ospf
-    include Ospf::Ip
-    include Ospf::Summary_Shared
-
-    attr :header
-    attr_accessor :mt_id
-
-    def initialize(arg={})
-      @netmask, @mt_id = 0, []
-      if arg.is_a?(Hash) then
-        arg[:lstype]=3 if arg[:lstype].nil?
-        @header = LSA_Header.new(arg)
-        set(arg)
-      elsif arg.is_a?(String)
-        __parse(arg)
-      else
-        raise ArgumentError, "Invalid argument", caller
-      end
-    end
-
-    def set(arg)
-      return self unless arg.is_a?(Hash)
-      @header.set(arg)
-      unless arg[:netmask].nil?
-        _netmask = arg[:netmask]
-        @netmask =  _netmask.is_a?(String) ? ip2long(_netmask) : _netmask
-      end      
-
-      unless arg[:metric].nil?
-        metric=arg[:metric]
-        @mt_id << MT.new({:metric=>metric})
-      end
-      unless arg[:mt_id].nil?
-        arg[:mt_id].each { |mt_id| 
-          mt_id.is_a?(MT) ? @mt_id << mt_id : @mt_id << MT.new(mt_id) 
-        }
-      end
-      self
-    end
-    
-    def <<(arg)
-      append_metric(arg)
-    end
-    
-    def enc
-      packet = @header.enc
-      packet+= __enc([[@netmask,'N'],])
-      packet +=@mt_id.collect {|mt_id| mt_id.enc}.join
-      packet_size(packet,@header)
-      packet_fletchsum(packet)
-    end
-
-    def __parse(s)
-      @header = LSA_Header.new(s)
-      arr = s[20..24].unpack("N")
-      @netmask = arr[0]
-      mt_ids = s[24..-1]
-      while mt_ids.size>0
-        @mt_id << MT.new(mt_ids.slice!(0,4))
-      end            
-    end
-    private :__parse
-
-    def to_s
-      enc
-      s = @header.to_s
-      s += "\n      netmask #{netmask}" 
-      s += "\n      " if @mt_id.size>0
-      s += @mt_id.collect { |mt| mt.to_s }.join("\n      ")
-    end
-    
-    def metric
-      @mt_id[0].metric
-    end
-
-  end
-
-  class SummaryLSA < SummaryLSAs
-    def initialize(arg={})
-      arg.merge!({:lstype => 3,}) if arg.is_a?(Hash)
-      super
-    end
-    def to_s_junos_style(rtype=' ')
-      __to_s_junos_style__('Summary', rtype)
-    end    
-    def to_hash
-      __to_hash__('Summary')
-    end
-  end
-
-  class ASBR_SummaryLSA < SummaryLSAs
-    def initialize(arg={})
-      arg.merge!({:lstype => 4, :metric=>0}) if arg.is_a?(Hash)
-      super(arg)
-    end
-     def to_s_junos_style(rtype=' ')
-       __to_s_junos_style__('ASBRSum', rtype)
-    end
-    def to_hash
-      __to_hash__('ASBRSum')
-    end
-  end
-end
-
-if __FILE__ == $0
-  load '../test/lsa_summary_test.rb'
-end
-
-