bgp4r 0.0.11 → 0.0.12

data/bgp/common.rb

@@ -42,17 +42,6 @@ class IPAddr
       IPAddr.new(arg)
     end
   end
-
-  def _mlen_
-    m = @mask_addr
-    len =  ipv6? ? 128 : 32
-    loop do
-      break if m & 1 > 0
-      m = m >> 1
-      len += -1
-    end
-    len
-  end
   
   def mlen
     @_jme_mlen_ ||= _mlen_
@@ -75,10 +64,22 @@ class IPAddr
     if ipv4?
       [@mask_addr].pack('N').unpack('C4').collect { |x| x.to_s}.join('.')
     else
-      #TODO netmask ipv6
-      @mask_addr
+      @mask_addr.to_s(16).scan(/..../).collect { |x| x }.join(':')
     end
   end
+  
+  private 
+  
+  def _mlen_
+    m = @mask_addr
+    len =  ipv6? ? 128 : 32
+    loop do
+      break if m & 1 > 0
+      m = m >> 1
+      len += -1
+    end
+    len
+  end
 
 end
 

data/bgp/iana.rb

@@ -30,6 +30,14 @@ module IANA
       ''
     end
   end
+  def self.afi?(arg)
+    @h_afis ||= AFI.set_h_afis
+    @h_afis[arg]
+  end
+  def self.safi?(arg)
+    @h_safis ||= SAFI.set_h_safis
+    @h_safis[arg]
+  end
   def self.safi(safi)
     case safi
     when SAFI::UNICAST_NLRI       ; 'Unicast'
@@ -68,8 +76,25 @@ module IANA
     FCWWNN = 23
     GWID = 24
     L2VPN = 25
-  end  
+    def self.set_h_afis
+      h_afis = Hash.new
+      constants.each do |c|
+        h_afis.store(c.downcase.to_sym, const_get(c))
+        h_afis.store(const_get(c), c.split('_').collect { |w| w }.join(' '))
+        # h_afis.store(const_get(c), c.downcase.to_sym)
+      end
+      h_afis
+    end
+  end
   module SAFI
+    def self.set_h_safis
+      h_safis = Hash.new
+      constants.each do |c|
+        h_safis.store(c.downcase.to_sym, const_get(c))
+        h_safis.store(const_get(c), c.split('_').collect { |w| w }.join(' '))
+      end
+      h_safis
+    end
     UNICAST_NLRI = 1
     MULTICAST_NLRI = 2
     LABEL_NLRI = 4

data/bgp/messages/capability.rb

@@ -68,9 +68,10 @@ module BGP
           @o1 &= ~1    if action_bit      == :advertise
           @seqn = seqn
           @cap = cap
-        elsif args.size==1 && args.is_a?(String)
-        else
+        elsif args.size==1 && args[0].is_a?(String)
           parse args[0]
+        else
+          raise ArgumentError, "Invalid argument #{args.inspect}"
         end
       end
 

data/bgp/messages/message.rb

@@ -47,14 +47,14 @@ module ::BGP
       len, @msg_type, message = s[16..-1].unpack('nCa*')
       message.is_packed
     end
-    def self.factory(_s, as4byte=false)
+    def self.factory(_s, session_info=nil)
       s = [_s].pack('a*')
       s.slice(18,1).unpack('C')[0]
       case s.slice(18,1).unpack('C')[0]
       when OPEN
         Open.new(s)
       when UPDATE
-        Update.new(s, as4byte)
+        Update.new(s, session_info)
       when KEEPALIVE
         Keepalive.new
       when NOTIFICATION
@@ -68,6 +68,7 @@ module ::BGP
       when CAPABILITY
         Capability.new(s)
       else
+        #FIXME: raise UnknownMessageTypeError() ...
         puts "don't know what kind of bgp messgage this is #{s.slice(18,1).unpack('C')}"
       end
     end

data/bgp/messages/open.rb

@@ -29,6 +29,7 @@
 # 
 require 'bgp/messages/message'
 require 'bgp/optional_parameters/capability'
+require 'ipaddr'
 
 module BGP
 
@@ -84,7 +85,7 @@ class Open < Message
   end
   
   def has?(klass)
-     @opt_parms.find { |a| a.is_a?(klass) }.nil? ? false : true
+     @opt_parms.find { |a| a.is_a?(klass) }
   end
   
   def to_hash

data/bgp/messages/update.rb

@@ -42,15 +42,28 @@ require 'bgp/path_attributes/path_attribute'
 
 class BGP::Update < BGP::Message
   include BGP
-  def as4byte?
-    @as4byte ||= false
+  
+  class Info
+    def initialize(*args)
+      @as4byte=args[0]
+    end
+    def as4byte?
+      @as4byte
+    end
+    def recv_inet_unicast?
+      false
+    end
   end
-  alias as4byte as4byte?
 
   def initialize(*args)
+    @nlri, @path_attribute, @withdrawn=nil,nil,nil
+    @session_info = Info.new
     if args[0].is_a?(String) and args[0].is_packed?
-      @as4byte=false
-      parse(*args)
+      if args.size==1
+        parse args[0], @session_info
+      else
+        parse(*args)
+      end
     elsif args[0].is_a?(self.class)
       parse(args[0].encode, *args[1..-1])
     else
@@ -67,47 +80,65 @@ class BGP::Update < BGP::Message
         self.path_attribute = arg
       elsif arg.is_a?(Nlri)
         self.nlri = arg
+      elsif arg.is_a?(Ext_Nlri)
+        self.nlri = arg
       end
     }
   end
 
+  def session_info=(val)
+    @session_info=val
+    raise unless val.respond_to? :as4byte?
+  end
+
   def withdrawn=(val)
     @withdrawn=val if val.is_a?(Withdrawn)
   end
 
   def nlri=(val)
-    @nlri=val if val.is_a?(Nlri)
+    @nlri=val if val.is_a?(Nlri) or val.is_a?(Ext_Nlri)
   end
 
   def path_attribute=(val)
     @path_attribute=val if val.is_a?(Path_attribute)
   end
 
-  def encode(as4byte=false)
-    @as4byte=as4byte
+  def encode(session_info=@session_info)
     withdrawn, path_attribute, nlri = '', '', ''
-    withdrawn = @withdrawn.encode(false) if defined? @withdrawn and @withdrawn
-    path_attribute = @path_attribute.encode(as4byte) if defined?(@path_attribute) and @path_attribute
-    nlri = @nlri.encode if defined? @nlri and @nlri
-    super([withdrawn.size, withdrawn, path_attribute.size, path_attribute, nlri].pack('na*na*a*'))
+    withdrawn = @withdrawn.encode if @withdrawn
+    path_attribute = @path_attribute.encode(session_info.as4byte?) if @path_attribute
+    super([withdrawn.size, withdrawn, path_attribute.size, path_attribute, encoded_nlri].pack('na*na*a*'))
   end
 
-  def encode4
-    encode(true)
+  def encode4()
+    encode(Info.new(true))
   end
 
-  attr_reader :path_attribute, :nlri, :withdrawn
+  attr_reader :path_attribute, :nlri, :withdrawn, :session_info
 
-  # CHANGED ME: NO DEFAULT HERE, the factory calling us has to tell what it is giving us.
-  def parse(s, as4byte=false)
-    @as4byte=as4byte
+  def parse(s, session_info)
     update = super(s)
+
     len = update.slice!(0,2).unpack('n')[0]
-    self.withdrawn=Withdrawn.new(update.slice!(0,len).is_packed) if len>0
+    
+    if len>0
+      s = update.slice!(0,len)
+      w =  Withdrawn.new_ntop(s,ext_nlri?(session_info))
+      self.withdrawn= w
+    end
+
     len = update.slice!(0,2).unpack('n')[0]
-    enc_path_attribute = update.slice!(0,len).is_packed
-    self.path_attribute=Path_attribute.new(enc_path_attribute, as4byte) if len>0
-    self.nlri = Nlri.new(update) if update.size>0
+    if len>0
+      enc_path_attribute = update.slice!(0,len).is_packed
+      self.path_attribute=Path_attribute.new(enc_path_attribute, session_info)
+    end
+
+    self.nlri = Nlri.factory(update, 1, 1, ext_nlri?(session_info)) if update.size>0
+    
+  end
+  
+  def ext_nlri?(session_info)
+    session_info and session_info.recv_inet_unicast?
   end
 
   def <<(val)
@@ -116,25 +147,39 @@ class BGP::Update < BGP::Message
       @path_attribute << val
     elsif val.is_a?(String)
       begin 
-        Nlri.new(val)
+        # Nlri.new(val)
         @nlri ||=Nlri.new
         @nlri << val
       rescue => e
+        p "JME: ***** #{val.inspect}"
+        p e
+        raise
       end
+    elsif val.is_a?(Ext_Nlri)
+      @nlri = val
     elsif val.is_a?(Nlri)
       val.to_s.split.each { |n| self << n }
+    else
+      raise ArgmentError, "Invalid arg: #{val.inspect}"
     end
   end
 
-  def to_s(as4byte=@as4byte)
-    # def to_s(fmt=:tcpdump)
-    msg = encode(as4byte)
+  def to_s(session_info=@session_info)
+    msg = encode(session_info)
     fmt=:tcpdump
     s = []
-    s << @withdrawn.to_s if defined?(@withdrawn) and @withdrawn
-    s << @path_attribute.to_s(fmt, as4byte) if defined?(@path_attribute) and @path_attribute
-    s << @nlri.to_s if defined?(@nlri) and @nlri
-    "Update Message (#{UPDATE}), #{as4byte ? "4 bytes AS, " : ''}length: #{msg.size}\n  " + s.join("\n") + "\n" + msg.hexlify.join("\n") + "\n"
+    if @withdrawn
+      s << "Withdrawn Routes:"
+      s << @withdrawn.to_s if @withdrawn
+    end
+
+    s << @path_attribute.to_s(fmt, session_info.as4byte?) if defined?(@path_attribute) and @path_attribute
+    if @nlri
+      s << "Network Layer Reachability Information:"
+      s << @nlri.to_s
+    end
+    "Update Message (#{UPDATE}), #{session_info.as4byte? ? "4 bytes AS, " : ''}length: #{msg.size}\n" +
+    s.join("\n") + "\n" + msg.hexlify.join("\n") + "\n"
   end
 
   def self.withdrawn(u)
@@ -146,6 +191,11 @@ class BGP::Update < BGP::Message
       Update.new(pa)
     end
   end
+
+  def encoded_nlri
+    @nlri.encode if @nlri
+  end
+
 end
 
 load "../../test/messages/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/neighbor/add_path_cap.rb

@@ -0,0 +1,125 @@
+#--
+# Copyright 2011 Jean-Michel Esnault.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#
+#
+# This file is part of BGP4R.
+# 
+
+module BGP
+  
+  class Neighbor
+    
+    class Base_Capabilities
+      
+      def initialize(speaker_open, peer_open)
+        @speaker = speaker_open # speaker_open.find(OPT_PARM::CAP::Add_path)
+        @peer    = peer_open    # peer_open.find(OPT_PARM::CAP::Add_path)
+      end
+      attr_reader :speaker, :peer
+      
+      def as4byte?
+        (! @speaker.has?(OPT_PARM::CAP::As4).nil? and  ! @peer.has?(OPT_PARM::CAP::As4).nil?)
+      end
+      
+      def path_id_recv? afi, safi
+        path_id? :recv, afi, safi
+      end
+      
+      def path_id_send? afi, safi
+        path_id? :send, afi, safi
+      end
+      
+      def path_id? action, afi, safi
+        case action
+        when :recv, 'recv'
+          _path_id?(speaker_add_path_cap, peer_add_path_cap, :recv, afi, safi)
+        when :send, 'send'
+          _path_id?(speaker_add_path_cap, peer_add_path_cap, :send, afi, safi)
+        else
+          raise ArgumentError, "Invalid argument #{action}, #{afi}, #{safi} #{action.inspect}"
+        end 
+      end
+      
+      private
+
+      def _path_id?(speaker, peer, sr, afi, safi)
+        return false unless speaker and peer
+        case sr
+        when :recv, 'recv'
+          speaker.has?(:recv, afi, safi) && peer.has?(:send, afi, safi)
+        when :send, 'send'
+          speaker.has?(:send, afi, safi) && peer.has?(:recv, afi, safi)
+        else
+          raise
+        end
+      end
+
+      def speaker_add_path_cap
+        @speaker.find(OPT_PARM::CAP::Add_path)
+      end
+      def peer_add_path_cap
+        @peer.find(OPT_PARM::CAP::Add_path)
+      end
+      
+      def method_missing(name, *args, &block)
+        if (/^(send|recv)_(ipv4|ipv6|inet|inet6)_(.+)\?$/ =~ name.to_s)
+          case $2
+          when 'ipv4', 'inet'   ; afi = IANA.afi?(:ip)
+          when 'ipv6', 'inet6'  ; afi = IANA.afi?(:ip6)
+          else
+            super
+          end
+          case $3
+          when 'unicast'            ; safi = IANA.safi?(:unicast_nlri)
+          when 'multicast'          ; safi = IANA.safi?(:multicast_nlri)
+          when 'mpls_vpn_unicast'   ; safi = IANA.safi?(:mpls_vpn_unicast)
+          when 'mpls_vpn_multicast' ; safi = IANA.safi?(:mpls_vpn_multicast)
+          else
+            super
+          end
+          def_method(name,$1, afi,safi)
+        else
+          super
+        end
+      end
+
+    private
+
+    def def_method(name, action, afi, safi)
+      self.class.instance_eval do
+        define_method("#{name}") do
+          path_id? action, afi, safi
+        end
+      end
+      __send__ name
+    end
+
+    end
+    
+    class Capabilities < Base_Capabilities
+      def initialize(*args)
+        @memory = {}
+        super
+      end
+      def as4byte?
+        if @memory.has_key?(:as4byte)
+          @memory[:as4byte]
+        else
+          @memory[:as4byte]=super
+        end
+      end
+      def path_id?(*args)
+        if @memory.has_key?([:path_id, *args])
+          @memory[[:path_id, *args]]
+        else
+          @memory[[:path_id, *args]]=super
+        end
+      end
+    end
+  end
+  
+end
+
+load "../../test/neighbor/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0