bgp4r 0.0.11 → 0.0.12

data/bgp/{neighbor.rb → neighbor/neighbor.rb}

@@ -24,21 +24,13 @@ require 'socket'
 require 'thread'
 require 'observer'
 require 'bgp/io'
+require 'bgp/neighbor/add_path_cap'
 
 module BGP
 
   class Neighbor
     include Observable
     
-    # def self.deprecate(old_method, new_method) 
-    #   define_method(old_method) do |*args, &block|
-    #     log_warn "#{old_method}() is deprecated. Use #{new_method}()."
-    #     __send__(new_method, *args, &block)
-    #   end 
-    # end
-    # 
-    # deprecate :send_message, :send
-
     def log_info(txt)
       Log.info "#{self.class} #{txt}"
     end
@@ -63,8 +55,8 @@ module BGP
       else
         @version, @my_as, @holdtime, @id, @remote_addr, @local_addr  = args
       end
-      @as4byte=false
       @state = :Idle
+      @session_info=nil
       @threads=ThreadGroup.new
       @mutex = Mutex.new
       @eventQ = Queue.new
@@ -77,12 +69,15 @@ module BGP
       end
     end
     
+    # FIXME:
+    #  neighbor.add_capability 
+    #  neighbor.remove_capability 
     #  neighbor.capability :as4_byte | :as4 | :as4byte
     #  neighbor.capability :route_refresh, :rr
     #  neighbor.capability :route_refresh, 128
     #  neighbor.capability :mbgp, :ipv4, :unicast
     #  neighbor.capability :mbgp, :ipv4, :multicast
-        
+    
     def capability(*args)
       @opt_parms << if args[0].is_a?(Symbol)
         case args[0]
@@ -103,6 +98,7 @@ module BGP
         raise ArgumentError, "Invalid argument"
       end
     end
+    alias :add_cap :capability
 
     def state
       "#{@state}"
@@ -115,7 +111,7 @@ module BGP
           Thread.current['name']='restart'
           loop do
             enable if @state == :Idle
-            sleep(5)
+            sleep(4)
           end
         end
 
@@ -132,7 +128,7 @@ module BGP
           ev, type, m = eventQ.deq
           case ev
           when :ev_msg
-            msg = BGP::Message.factory(m, @as4byte)
+            msg = BGP::Message.factory(m, @session_info)
             log_info "Recv#{msg.class.to_s.split('::').last}"
             log_debug "Recv #{msg}\n"
             if msg.is_a?(Update)
@@ -153,17 +149,17 @@ module BGP
             changed and notify_observers(msg)
           when :ev_conn_reset
             Log.warn "#{type}"
-            disable
+            stop
           when :ev_holdtime_expire
             Log.warn "Holdtime expire: #{type}"
-            disable
+            stop
           else
             Log.error "unexpected event #{ev}"
           end
         end
       end
     end
-
+    
     def clean
       @threads.list.each { |x| 
         x.exit; x.join
@@ -183,42 +179,42 @@ module BGP
       @holdtime ||= 180
     end
     
-    def enable(auto_retry=:no_auto_retry, wait= :wait)
+    def start_session(session)
+      @socket=session
+      return unless  @state == :Idle
+      init_io
+      send_open :ev_send_open
+    end
+    
+    def start(arg={})
+      options = {:port=> 179, :auto_retry=> false, :no_blocking=>false, :waitfor=> :Established}.merge(arg)
       return if @state == :Established
-      disable unless @state == :Idle
-      
-      init_socket
+      stop unless @state == :Idle
+      if options[:session]
+        @socket = session
+      else
+        @socket = TCPSocket.new(@remote_addr, options[:port])
+      end
       init_io
-            
-      [@in, @out].each { |io| 
-        io.start 
-        @threads.add io.thread
-      }
-            
       send_open :ev_send_open
-      
-      retry_thread if auto_retry == :auto_retry
-      
-      if wait == :wait
+      retry_thread if options[:auto_retry] == true
+      unless options[:no_blocking] == true
         loop do
           sleep(0.3)
-          break if @state == :Established
+          break if @state == options[:waitfor]
         end
         log_info "#{self} started"
       end
-      
     rescue => e
       Log.error "#{e}"
-      disable
+      stop
     end
-    alias start enable
         
-    def disable
+    def stop
       @socket.close  if defined?(@socket) and not @socket.closed?
       clean
       new_state :Idle, "Disable"
     end
-    alias stop disable
 
     define_method(:in) do
       @in.thread
@@ -227,7 +223,11 @@ module BGP
       @out.thread
     end
 
-    attr_reader :as4byte
+    attr_reader :as4byte, :session_info
+    
+    def as4byte?
+      @session_info.as4byte?
+    end
 
     def send_message(m)
       raise if m.nil?
@@ -236,30 +236,23 @@ module BGP
         log_info "Send#{m.class.to_s.split('::')[-1]}"
         log_debug "Send #{m.is_a?(Update) ? m.to_s : m }\n"
       end
-      #FIXME: enqueue [m, as4byte]
       if m.is_a?(Update)
-        @out.enq m.encode(as4byte)
+         send_update m
       else
         @out.enq m
       end
     end
-
-    def init_socket
-      @socket = Socket.new(Socket::PF_INET, Socket::SOCK_STREAM, Socket::IPPROTO_TCP)
-      remote = Socket.pack_sockaddr_in(179, @remote_addr) 
-      local = Socket.pack_sockaddr_in(0, @local_addr) unless @local_addr.nil?
-      remote_sock_addr = Socket.pack_sockaddr_in(179, @remote_addr) 
-      local_sock_addr = Socket.pack_sockaddr_in(0, @local_addr) unless @local_addr.nil? 
-      @socket.bind(local_sock_addr) unless @local_addr.nil?
-      @socket.connect(remote_sock_addr)
-    end
-      
+    
     def init_io
       @in = BGP::IO::Input.new(@socket, holdtime, self)
       @out = BGP::IO::Output.new(@socket, @holdtime, self)
       new_state(:Active, "Open Socket")
+      [@in, @out].each { |io| 
+        io.start 
+        @threads.add io.thread
+      }
     end
-        
+    
     def update(*args)
       @eventQ.enq(args)
     end
@@ -268,7 +261,11 @@ module BGP
       log_info "#{txt} old state #{@state} new state #{state}"
       @state = state
     end
-
+    
+    def send_update(u)
+      @out.enq u.encode(@session_info)
+    end
+    
     def send_open(ev)
       case @state
       when :OpenRecv
@@ -277,18 +274,17 @@ module BGP
         send_message open  ; new_state :OpenSent, ev
       else
         Log.warn "#{self.class}: attempt to send OPEN msg while in #{@state}"
-      end    
+      end
     end
   
-    def rcv_open(o)
-      @rmt_version = o.version
-      @rmt_as = o.local_as
-      @rmt_bgp_id = o.bgp_id
-
-      if @holdtime > o.holdtime
-        @out.holdtime = @in.holdtime = o.holdtime
-      end
-
+    def rcv_open(peer_open)
+      @session_info = Neighbor::Capabilities.new open, peer_open
+      
+      @rmt_version  = peer_open.version
+      @rmt_as       = peer_open.local_as
+      @rmt_bgp_id   = peer_open.bgp_id
+      @out.holdtime = @in.holdtime = peer_open.holdtime if @holdtime > peer_open.holdtime
+      
       case @state
       when :OpenSent
         send_message(BGP::Message.keepalive)
@@ -299,7 +295,7 @@ module BGP
       else
         Log.warn "#{self.class}: received open message while in state #{@state}"
       end
-      @as4byte = (open.has?(OPT_PARM::CAP::As4) && o.has?(OPT_PARM::CAP::As4))
+      
     end
     
     def rcv_keepalive
@@ -317,25 +313,25 @@ module BGP
         @threads.add(@keepalive_thread)
       end
     end
-
+    
     def rcv_notification(m)
       log_info "#{m}"
       changed and notify_observers(m)
-      disable
+      stop
     end
     
     def rcv_route_refresh(m)
     end
-
+    
     def rcv_update(m)
     end
     
     def to_s
       "version: #{version}, id: #{@id}, as: #{@my_as}, holdtime: #{@holdtime}, peer addr: #{@remote_addr}, local addr: #{@local_addr}"
     end
-
+    
   end
 
 end
 
-load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0
+load "../../test/neighbor/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/nlris/nlri.rb

@@ -29,6 +29,7 @@ module BGP
   class Base_nlri
 
     class Nlri_element < IPAddr
+
       def to_s
         [super, mlen].join('/')
       end
@@ -36,7 +37,7 @@ module BGP
         hton
       end
       def nbyte
-         (mlen+7)/8
+        (mlen+7)/8
       end
       def encode(len_included=true)
         nbyte = (mlen+7)/8
@@ -46,13 +47,14 @@ module BGP
           [hton].pack("a#{nbyte}")
         end
       end
-      def parse4(arg)
+      def parse(arg)
         s = arg.dup
         s +=([0]*3).pack('C*')
         plen, *nlri = s.unpack('CC4')
         arg.slice!(0,1+(plen+7)/8) # trim arg accordingly
         ipaddr = nlri.collect { |n| n.to_s }.join('.') + "/" + plen .to_s
       end
+      alias :parse4 :parse
       def parse6(arg)
         s = arg.dup
         s +=([0]*16).pack('C*')
@@ -71,6 +73,10 @@ module BGP
         else
           super(arg)
         end
+      rescue => e
+        p e
+        p arg
+        raise
       end
     end
 
@@ -86,18 +92,90 @@ module BGP
       end
     end
 
+    class Ext_Nlri_element < Nlri_element
+      def initialize(*args)
+        if args.size>1
+          @path_id = args.shift
+          super
+        elsif args.size==1 and args[0].is_a?(String)
+          super parse(*args)
+        elsif args.size==1 and args[0].is_a?(Hash)
+          @path_id=args[0][:path_id]
+          super args[0][:nlri_element]
+        else
+          raise
+        end
+      rescue => e
+        p e
+        p args
+        raise
+      end
+      attr_reader :path_id
+      def encode
+        [path_id, super].pack('Na*')
+      end
+      def to_s
+        "ID: #{path_id}, #{super}"
+      end
+      def parse(s)
+        @path_id = s.slice!(0,4).unpack('N')[0]
+        super s
+      end
+    end
+
     attr_reader :nlris
+    
+    class << self
+      def new_ntop(s, extended=false)
+        if extended
+          nlri = new
+          while s.size>0
+            nlri.add Base_nlri::Ext_Nlri_element.new(s)
+          end
+          nlri
+        else
+          new(s.is_packed)
+        end
+      end
+    end
 
     def initialize(*args)
       if args[0].is_a?(String) and args[0].is_packed?
-        parse(args[0])
+        parse(*args)
       else
         add(*args)
       end
     end
     def add(*args)
       @nlris ||=[]
-      args.flatten.each { |arg| @nlris << Ip4.new(arg) }
+      args.each { |arg|
+        case arg
+        when Hash
+          if arg.has_key? :path_id
+            @nlris << Ext_Nlri_element.new(arg)
+          else
+            raise
+          end
+        when String
+          # p "JME: IN ADD/ STRING:"
+          # p arg
+          # p arg.is_packed?
+          # p "---"
+          o = Ip4.new(arg)
+          # p o
+          @nlris << o
+        when Array
+          if arg[0].is_a?(Integer)
+            @nlris << Ext_Nlri_element.new(*arg)
+          else
+            raise
+          end
+        when Ext_Nlri_element, Ip4
+          @nlris << arg
+        else
+          raise ArgumentError, "Invalid argument #{arg.class} #{arg.inspect}"
+        end
+      }
     end
     alias << add
 
@@ -117,10 +195,10 @@ module BGP
       end
     end
 
-    def to_s
-      @nlris.join("\n")
+    def to_s(indent=0)
+      @nlris.join("\n#{([' ']*indent).join}")
     end
-    
+
     def size
       @nlris.size
     end
@@ -132,23 +210,219 @@ module BGP
       super
     end
   end
+
   class Withdrawn < Base_nlri
-    def encode(len_included=true)
-      super(len_included)
+    class << self
+      def new_top(*args)
+        super
+      end
+    end
+    class << self
+      def new_ntop(s, extended=false)
+        if extended
+          nlri = new
+          while s.size>0
+            nlri.add Base_nlri::Ext_Nlri_element.new(s)
+          end
+          nlri
+        else
+          new(s.is_packed)
+        end
+      end
+    end
+    def encode
+      super
     end
   end
 
   class Nlri
-    def self.factory(s, afi, safi)
-      case safi
-      when 1,2
-        Prefix.new(s.is_packed, afi)
-      when 4,128,129
-        Labeled.new(s.is_packed, afi, safi)
+    def self.factory(s, afi, safi, extended=false)
+      if afi== 1 and safi==1
+        Nlri.new_ntop(s.is_packed, extended)
+      else
+        case safi
+        when 1,2
+          Prefix.new(s.is_packed, afi)
+        when 4,128,129
+          Labeled.new(s.is_packed, afi, safi)
+        else
+          raise RuntimeError, "Afi #{afi} Safi #{safi} not supported!"
+        end
       end
     end
   end
 
+  class Ext_Nlri
+    def self.factory(s, afi, safi)
+      new_ntop s, afi, safi
+    end
+    def self.new_ntop(s, afi=1, safi=1)
+      path_id = s.slice!(0,4).unpack('N')[0]
+      nlri = Nlri.factory(s, afi, safi)
+      new path_id, nlri
+    end
+    attr :path_id, :nlri
+    def initialize(path_id, nlri)
+      @path_id=path_id
+      @nlri = nlri
+    end
+    def afi
+      @nlri.afi
+    end
+    def to_s
+      s = []
+      s << "ID=#{@path_id}"
+      s << @nlri.to_s
+      s.join(", ")
+    end
+    def encode
+      [@path_id, @nlri.encode].pack('Na*')
+    end
+  end
+
 end
 
 load "../../test/nlris/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0
+
+
+__END__
+
+
+Nlri is a collection of Nlri_elements or a collection of Path_nlri_elements
+
+
+Path_nlri_element
+
+- path_id
+- Nlri_element
+
+
+
+3. Extended NLRI Encodings
+
+In order to carry the Path Identifier in an UPDATE message, the
+existing NLRI encodings are extended by prepending the Path
+Identifier field, which is of four-octets.
+
+For example, the NLRI encodings specified in [RFC4271, RFC4760] are
+extended as the following:
+
+
++--------------------------------+
+| Path Identifier (4 octets)     |
++--------------------------------+
+| Length (1 octet)               |
++--------------------------------+
+| Prefix (variable)              |
++--------------------------------+
+
+
+and the NLRI encoding specified in [RFC3107] is extended as the
+following:
+
+
+
+
+
+Walton, et al        Expiration Date February 2011              [Page 3]
+
+
+
+
+
+INTERNET DRAFT      draft-ietf-idr-add-paths-04.txt          August 2010
+
+
++--------------------------------+
+| Path Identifier (4 octets)     |
++--------------------------------+
+| Length (1 octet)               |
++--------------------------------+
+| Label (3 octets)               |
++--------------------------------+
+| ...                            |
++--------------------------------+
+| Prefix (variable)              |
++--------------------------------+
+
+
+The usage of the extended NLRI encodings is specified in the
+Operation section.
+
+
+
+=======
+
+RFC 3107          Carrying Label Information in BGP-4           May 2001
+
+
+3. Carrying Label Mapping Information
+
+Label mapping information is carried as part of the Network Layer
+Reachability Information (NLRI) in the Multiprotocol Extensions
+attributes.  The AFI indicates, as usual, the address family of the
+associated route.  The fact that the NLRI contains a label is
+indicated by using SAFI value 4.
+
+The Network Layer Reachability information is encoded as one or more
+triples of the form <length, label, prefix>, whose fields are
+described below:
+
++---------------------------+
+|   Length (1 octet)        |
++---------------------------+
+|   Label (3 octets)        |
++---------------------------+
+.............................
++---------------------------+
+|   Prefix (variable)       |
++---------------------------+
+
+The use and the meaning of these fields are as follows:
+
+a) Length:
+
+The Length field indicates the length in bits of the address
+prefix plus the label(s).
+
+b) Label:
+
+The Label field carries one or more labels (that corresponds to
+the stack of labels [MPLS-ENCAPS]).  Each label is encoded as 3
+octets, where the high-order 20 bits contain the label value,
+and the low order bit contains "Bottom of Stack" (as defined in
+[MPLS-ENCAPS]).
+
+c) Prefix:
+
+The Prefix field contains address prefixes followed by enough
+trailing bits to make the end of the field fall on an octet
+boundary.  Note that the value of trailing bits is irrelevant.
+
+
+
+Rekhter & Rosen             Standards Track                     [Page 3]
+
+RFC 3107          Carrying Label Information in BGP-4           May 2001
+
+
+The label(s) specified for a particular route (and associated with
+its address prefix) must be assigned by the LSR which is identified
+by the value of the Next Hop attribute of the route.
+
+When a BGP speaker redistributes a route, the label(s) assigned to
+that route must not be changed (except by omission), unless the
+speaker changes the value of the Next Hop attribute of the route.
+
+A BGP speaker can withdraw a previously advertised route (as well as
+the binding between this route and a label) by either (a) advertising
+a new route (and a label) with the same NLRI as the previously
+advertised route, or (b) listing the NLRI of the previously
+advertised route in the Withdrawn Routes field of an Update message.
+The label information carried (as part of NLRI) in the Withdrawn
+Routes field should be set to 0x800000.  (Of course, terminating the
+BGP session also withdraws all the previously advertised routes.)
+
+
+
+

data/bgp/nlris/prefix.rb

@@ -1,6 +1,6 @@
 require 'bgp/nlris/nlri'
 module BGP
-  class Prefix < Nlri::Nlri_element
+  class Prefix < Base_nlri::Nlri_element
     def initialize(*args)
       if args[0].is_a?(String) and args[0].packed?
         afi = args[1] ||=1
@@ -30,4 +30,5 @@ module BGP
   end
 end
 
-load "../../test/nlris/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0
+# FIXME:
+# load "../../test/nlris/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/nlris/vpn.rb

@@ -52,17 +52,10 @@ module BGP
       @prefix.ipv6?
     end
     def parse(s, afi=1)
-      # p "-----------"
-      # p s.unpack('H*')
-      # p afi
       nbits = s.slice!(0,1).unpack('C')[0]
       rd,vpn = s.slice!(0,(7+nbits)/8).unpack("a8a*")
       @rd = Rd.new(rd.is_packed)
-      # p @rd
-      # p nbits
-      # p vpn.unpack('H*')
-      raise if nbits-64==0
-      @prefix= Prefix.new([nbits-64,vpn].pack('Ca*'), afi) if nbits-64>0
+      @prefix= Prefix.new([nbits-64,vpn].pack('Ca*'), afi)
     end
     def nexthop
       @prefix.nexthop