bgp4r 0.0.13 → 0.0.14

data/bgp/messages/update.rb

@@ -183,6 +183,14 @@ class BGP::Update < BGP::Message
     s.join("\n") + "\n" + msg.hexlify.join("\n") + "\n"
   end
 
+  def to_hash
+    h = {}
+    h[:withdrawns] = @withdrawn.to_ary if @withdrawn
+    h[:path_attributes] = @path_attribute.to_hash if @path_attribute
+    h[:nlris] = @nlri.to_ary if @nlri
+    h
+  end
+
   def self.withdrawn(u)
     if u.nlri and u.nlri.size>0
       Update.new(Withdrawn.new(*(u.nlri.nlris.collect { |n| n.to_s})))

data/bgp/nlris/label.rb

@@ -58,8 +58,10 @@ module BGP
       @label_stack=[]
       if args.size==1 and args[0].is_a?(String) and args[0].is_packed?
         parse(args[0])
+      elsif args.size==1 and args[0].is_a?(Hash)
+        @label_stack = args[0][:labels].collect { |l| Label.new(l) }
       else
-        args.each { |arg| @label_stack << (arg.is_a?(Label) ? arg : Label.new(arg)) }
+        @label_stack = args.collect { |arg| (arg.is_a?(Label) ? arg : Label.new(arg)) }
       end
     end
     def size
@@ -84,6 +86,12 @@ module BGP
         "Label Stack=#{@label_stack.collect{ |l| l.label }.join(',')} (bottom)"
       end
     end
+    def to_ary
+      @label_stack.collect { |e| e.label }
+    end
+    def to_hash
+      @label_stack.size==1 ? {:label=>@label_stack[0].label} :  {:labels=> to_ary} 
+    end
     def bit_length
       @label_stack.compact.size*24
     end

data/bgp/nlris/labeled.rb

@@ -17,6 +17,11 @@ module BGP
     def initialize(*args)
       if args.size>0 and args[0].is_a?(String) and args[0].is_packed?
         parse(*args)
+      elsif args.size==1 and args[0].is_a?(Hash)
+        # TODO: a new_prefix :prefix=>, :labels=>
+        #                    :other=> ...
+        @prefix = Prefix.new(args[0][:prefix]) # assuming it's a Prefix, which it may not be
+        @labels = Label_stack.new(*args[0][:labels])
       else
         @prefix, *labels = args
         @labels = Label_stack.new(*labels)
@@ -25,6 +30,9 @@ module BGP
     #FIXME... a mixin path_id ????
     def path_id
       @prefix.path_id
+    rescue
+      # return nil
+      # RD: 0/0
     end
     def path_id=(val)
       @prefix.path_id=val
@@ -40,6 +48,9 @@ module BGP
         s
       end
     end
+    def to_hash
+      @labels.to_hash.merge(@prefix.to_hash)
+    end
     def to_s
       "#{@labels} #{@prefix}"
     end

data/bgp/nlris/nlri.rb

@@ -94,18 +94,29 @@ module BGP
     def to_s(indent=0)
       @nlris.join("\n#{([' ']*indent).join}")
     end
-
+    
     def size
       @nlris.size
     end
 
+    def to_ary
+      @nlris.collect { |n| n.to_s }
+    end
+
   end
 
   unless const_defined?(:Nlri)
-    Nlri      = Class.new(Base_nlri)
-    Withdrawn = Class.new(Base_nlri)
+    Nlri      = Class.new(Base_nlri) do
+      def to_hash
+        {:nlris=>to_ary}
+      end
+    end
+    Withdrawn = Class.new(Base_nlri) do
+      def to_hash
+        {:withdrawns=>to_ary}
+      end
+    end
   end
-  
   class Nlri
     def self.factory(s, afi, safi, path_id=nil)
       if afi== 1 and safi==1

data/bgp/nlris/prefix.rb

@@ -54,6 +54,9 @@ class Prefix
     @path_id=nil
     if args.size>1 and args[0].is_a?(Integer)
       @path_id, pfx, afi = args
+    elsif args.size==1 and args[0].is_a?(Hash)
+      @path_id = args[0][:path_id]
+      pfx = args[0][:prefix]
     else
       pfx, afi = args
     end
@@ -108,6 +111,14 @@ class Prefix
     end
   end
   
+  def to_hash
+    if extended?
+      {:prefix=> pfx_to_s}.merge({:path_id=>@path_id})
+    else
+      {:prefix=> pfx_to_s}
+    end
+  end
+  
   def nexthop
     to_s.split('/')[0]
   end

data/bgp/nlris/rd.rb

@@ -54,9 +54,21 @@ module BGP
         else
           @admin, @assign, @enc_type,  = admin, assign, 0
         end
+      elsif args.size==1 and args[0].is_a?(Hash)
+        # assuming Rd.new :rd=> [100,100]
+        parse(Rd.new(*args[0][:rd]).encode)
       end
     end
-
+    
+    def to_hash
+      #FIXME
+      if @admin.is_a?(IPAddr)
+        {:rd=> [@admin.to_s, @assign]}
+      else
+        {:rd=> [@admin, @assign]}
+      end
+    end
+    
     def encode
       case @enc_type
       when 0

data/bgp/nlris/vpn.rb

@@ -11,12 +11,20 @@ module BGP
   class Vpn
     attr_reader :prefix, :rd
     def initialize(*args)
+      @prefix=nil
       if args.size>0 and args[0].is_a?(String) and args[0].is_packed?
         parse(*args)
       else
-        prefix, *rd = args
-        self.prefix=(prefix)
-        self.rd=rd
+        case args[0]
+        when String, Prefix
+          prefix, *rd = args
+          self.prefix=(prefix)
+          self.rd=rd
+        when Rd
+          *rd = args
+          @prefix=nil
+          self.rd=rd
+        end
       end      
     end
     def prefix=(arg)
@@ -42,23 +50,38 @@ module BGP
     end
     def encode(len_included=true)
       if len_included
-        [bit_length, @rd.encode, @prefix.encode_with_len_without_path_id].pack('Ca*a*')
+        [bit_length, @rd.encode, encode_prefix(false)].pack('Ca*a*')
       else
-        @rd.encode + @prefix.encode_without_len_without_path_id
+        @rd.encode + encode_prefix(false)
       end
     end
+    
+    def encode_prefix(len_included)
+      if @prefix
+        if len_included
+          @prefix.encode_with_len_without_path_id
+        else
+          @prefix.encode_without_len_without_path_id
+        end
+      else
+        ''
+      end
+    end
+    
     def encode_without_len_without_path_id
       encode(false)
     end
+    
     def path_id
       @prefix.path_id
-    rescue
     end
     def path_id=(val)
       @prefix.path_id=val
     end
     def bit_length
-      @rd.bit_length + @prefix.mlen
+      len = @rd.bit_length 
+      len += @prefix.mlen if @prefix
+      len
     end
     def ipv4?
       @prefix.ipv4?
@@ -73,14 +96,40 @@ module BGP
       nbits = s.slice!(0,1).unpack('C')[0]
       rd,vpn = s.slice!(0,(7+nbits)/8).unpack("a8a*")
       @rd = Rd.new(rd.is_packed)
-      @prefix= Prefix.new_ntop([nbits-64,vpn].pack('Ca*'), afi)
+      @prefix= Prefix.new_ntop([nbits-64,vpn].pack('Ca*'), afi) if vpn.size>0
     end
     def nexthop
       @prefix.nexthop
     end
-    def to_s
+    def to_s(afi=1)
        #Label Stack=5806 (bottom) RD=3215:317720610, IPv4=10.45.142.64/32
-      "#{@rd.to_s(false)}, #{@prefix.to_s_with_afi}"
+      "#{@rd.to_s(false)}, #{prefix_to_s(afi)}"
+    end
+    
+    def to_hash
+      if @prefix
+        @rd.to_hash.merge(@prefix.to_hash)
+      else
+        @rd.to_hash
+      end
     end
+    
+    private
+    
+    def prefix_to_s(afi)
+      if @prefix
+        @prefix.to_s_with_afi
+      else
+        case afi
+        when 1 ; 'IPv4=0.0.0.0/0'
+        when 2 ; 'IPv6=0::0/0'
+        else
+          ''
+        end
+      end
+    end
+    
   end
 end
+
+load "../../test/unit/nlris/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/path_attributes/aggregator.rb

@@ -36,6 +36,9 @@ module BGP
         @as = args[1]
       elsif args[0].is_a?(self.class)
         parse(args[0].encode, *args[1..-1])
+      elsif args[0].is_a?(Hash)
+        @ip_address = IPAddr.create(args[0][:address])
+        @as = args[0][:asn]
       else
         raise ArgumentError, "invalid argument, #{args.inspect}"
       end
@@ -48,6 +51,10 @@ module BGP
     def address
       @ip_address.to_s
     end
+    
+    def asn
+      @as
+    end
 
     def as(sep='')
       case sep
@@ -78,6 +85,10 @@ module BGP
       super([@as].pack(f) + @ip_address.hton)
     end
     
+    def to_hash
+      {:asn=> asn, :address=> address}
+    end
+    
   end
 
   class As4_aggregator < Aggregator
@@ -98,6 +109,14 @@ module BGP
     end
 
   end
+  
+  class Aggregator
+    class << self
+      def new_hash(arg={})
+        new arg[:address], arg[:as]
+      end
+    end    
+  end
 
 end
 

data/bgp/path_attributes/aigp.rb

@@ -0,0 +1,63 @@
+require 'bgp/path_attributes/attribute'
+
+module BGP
+
+  class Aigp < Attr
+
+    def initialize(*args)
+      @flags, @type = OPTIONAL_NON_TRANSITIVE, ACCUMULATED_IGP_METRIC
+      if args[0].is_a?(String) and args[0].is_packed?
+        parse(args[0])
+      elsif args[0].is_a?(self.class)
+        parse(args[0].encode, *args[1..-1])
+      elsif args.size==1 and args[0].is_a?(Integer)
+        @aigp = args[0]
+      elsif args.empty?
+        @aigp=0
+      else
+        raise
+      end
+    end
+
+    def to_i
+      @aigp.to_i
+    end
+    
+    def to_hash
+      {:metric=> to_i}
+    end
+    
+    def accumulated_igp_metric
+      format("(0x%8.8x) %d", to_i, to_i)
+    end
+    alias metric accumulated_igp_metric
+    
+    def to_s(method=:default)
+      super(accumulated_igp_metric, method)
+    end
+
+    def encode
+      super([1, 11, @aigp >> 32, @aigp & 0xffffffff].pack('CnN2'))
+    end
+
+    def parse(s)
+      @flags, @type, len, value=super(s)
+      _, _, high, low = value.unpack('CnNN')
+      @aigp = (high << 32) + low
+    end
+
+  end
+
+  class Aigp
+    class << self
+      def new_hash(_arg={})
+        arg = {:metric=>0}.merge(_arg)
+        new arg[:metric]
+      end
+    end
+  end
+
+
+end
+
+load "../../test/unit/path_attributes/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/path_attributes/as_path.rb

@@ -117,6 +117,9 @@ module BGP
             super(:set, *args)
           end
         end
+        def to_hash
+          {:set=> as}
+        end
       end
       
       class As_path::Sequence < As_path::Segment
@@ -127,6 +130,9 @@ module BGP
             super(:sequence, *args)
           end
         end
+        def to_hash
+          {:sequence=> as}
+        end        
       end
       
       class As_path::Confed_set < As_path::Segment
@@ -137,6 +143,9 @@ module BGP
             super(:confed_set, *args)
           end
         end
+        def to_hash
+          {:confed_set=> as}
+        end        
       end
       
       class As_path::Confed_sequence < As_path::Segment
@@ -147,6 +156,9 @@ module BGP
             super(:confed_sequence, *args)
           end
         end
+        def to_hash
+          {:confed_sequence=> as}
+        end        
       end
       
       def integer?(arg)
@@ -204,6 +216,12 @@ module BGP
         @segments.find { |s| s.seg_type == SEQUENCE }
       end
       
+      def to_hash
+        h = {}
+        @segments.each { |s| h = h.merge(s.to_hash) }
+        { :as_path=> h}
+      end
+      
       private
       
       def parse(s,as4byte=false)
@@ -225,6 +243,45 @@ module BGP
       end
     end
     
+    class As_path
+      class << self
+        def new_hash(arg={})
+          o = new
+          [:set, :sequence, :confed_sequence, :confed_set].each do |set_type|
+            next unless arg.has_key? set_type
+            case set_type
+            when :set
+              o << As_path::Set.new(*arg[:set])
+            when :sequence
+              o << As_path::Sequence.new(*arg[:sequence])
+            when :confed_set
+              o << As_path::Confed_set.new(*arg[:confed_set])
+            when :confed_sequence
+              o << As_path::Confed_sequence.new(*arg[:confed_sequence])
+            else
+              raise
+            end 
+          end
+          o
+        end
+      end
+    
+      class << self
+        def new_set(*args)
+          new_hash :set=>args
+        end
+        def new_sequence(*args)
+          new_hash :sequence=>args
+        end
+        def new_confed_set(*args)
+          new_hash :confed_set=>args
+        end
+        def new_confed_sequence(*args)
+          new_hash :confed_sequence=>args
+        end
+      end
+    end
+    
 end
 
 load "../../test/unit/path_attributes/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/path_attributes/atomic_aggregate.rb

@@ -35,6 +35,9 @@ module BGP
         raise ArgumentError, "invalid argument, #{arg.class} #{arg}"
       end
     end
+    def to_hash
+      {}
+    end
   end
 
 end

data/bgp/path_attributes/attribute.rb

@@ -45,6 +45,8 @@ module BGP
     AS4_PATH = 17
     AS4_AGGREGATOR = 18
     
+    ACCUMULATED_IGP_METRIC = 26
+    
     SET = 1
     SEQUENCE = 2
     CONFED_SEQUENCE = 3
@@ -136,6 +138,14 @@ module BGP
       s +="]"
     end
     
+    def is_optional?
+       (@flags&8>0)
+    end
+    
+    def is_transitive?
+      (@flags&4>0)
+    end
+    
     def attribute_name
       name.split('_').collect { |w| w.capitalize }.join(' ')
     end

data/bgp/path_attributes/attributes.rb

@@ -12,6 +12,7 @@
   mp_unreach 
   extended_communities 
   path_attribute
+  aigp
 }.each do |attr|
   require "bgp/path_attributes/#{attr}"
 end

data/bgp/path_attributes/cluster_list.rb

@@ -100,7 +100,11 @@ module BGP
     def sort
       Cluster_list.new(to_ary.sort)
     end
-
+    
+    def to_hash
+      {:cluster_ids=>@cluster_ids.collect { |c| c.to_s  }}
+    end
+      
     def sort!
       @cluster_ids = @cluster_ids.sort_by { |c| c.to_i }
       self
@@ -111,6 +115,25 @@ module BGP
     end
 
   end
+  
+  class Cluster_list
+    class << self
+      def new_hash(arg={})
+        o = new
+        [:cluster_ids].each do |set_type|
+          next unless arg.has_key? set_type
+          case set_type
+          when :cluster_ids
+            o << arg[set_type]
+          else
+            raise
+          end 
+        end
+        o
+        
+      end
+    end
+  end
 
 end
 

data/bgp/path_attributes/communities.rb

@@ -27,7 +27,17 @@ module BGP
   class Communities < Attr
 
     class Community
-      
+
+      class << self
+        def method_missing(name, *args, &block)
+          if name.to_s =~ /^(no_export|no_advertise|no_export_sub_confed|no_peer)$/
+            new name
+          else
+            super
+          end
+        end
+      end
+
       unless const_defined? :NO_EXPORT
         NO_EXPORT             = 0xFFFFFF01
         NO_ADVERTISE          = 0xFFFFFF02
@@ -79,6 +89,22 @@ module BGP
 
     end
 
+    class << self
+      def new_hash(arg={})
+        o = new
+        [:communities].each do |set_type|
+          next unless arg.has_key? set_type
+          case set_type
+          when :communities
+            o << arg[set_type]
+          else
+            raise
+          end 
+        end
+        o
+      end
+    end
+
     def initialize(*args)
       @flags, @type = OPTIONAL_TRANSITIVE, COMMUNITIES
       if args[0].is_a?(String) and args[0].is_packed?
@@ -114,6 +140,10 @@ module BGP
     def to_s(method=:default)
       super(communities, method)
     end
+    
+    def to_hash
+      { :communities=> @communities.collect { |comm| comm.to_s } }
+    end
 
     def encode
       super(@communities.collect { |comm| comm.encode }.join)
@@ -171,4 +201,5 @@ module BGP
   end
   
 end
+
 load "../../test/unit/path_attributes/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/path_attributes/extended_communities.rb

@@ -28,6 +28,26 @@ module BGP
 
   class Extended_communities < Attr
 
+    class << self
+      def new_hash(arg={})
+        o = new
+        arg.keys.each do |comm|
+          case comm
+          when :color           ; o << Color.new(*arg[comm])
+          when :route_target    ; o << Route_target.new(*arg[comm])
+          when :link_bandwidth  ; o << Link_bandwidth.new(*arg[comm])
+          when :ospf_domain_id  ; o << Ospf_domain_id.new(*arg[comm])
+          when :encapsulation   ; o << Encapsulation.new(*arg[comm])
+          when :route_origin    ; o << Route_origin.new(*arg[comm])
+          when :ospf_router_id  ; o << Ospf_router_id.new(arg[comm])
+          else
+            raise
+          end 
+        end
+        o        
+      end
+    end
+
     attr_reader :communities
 
     def initialize(*args)
@@ -59,6 +79,12 @@ module BGP
     end
     alias << add
 
+    def to_hash
+      h = {}
+      @communities.each { |c|  h = h.merge( { c.class.to_s.split('::').last.downcase.to_sym => c.instance_eval { value2 } }) }
+      h
+    end
+
     def extended_communities
       len = @communities.size*8
       s=[]