bgp4r 0.0.8 → 0.0.9

data/bgp/messages/route_refresh.rb

@@ -0,0 +1,181 @@
+#  Route-REFRESH Message
+#  
+#     The ROUTE-REFRESH message is a new BGP message type defined as
+#     follows:
+#  
+#            Type: 5 - ROUTE-REFRESH
+#  
+#            Message Format: One <AFI, SAFI> encoded as
+#  
+#                    0       7      15      23      31
+#                    +-------+-------+-------+-------+
+#                    |      AFI      | Res.  | SAFI  |
+#                    +-------+-------+-------+-------+
+#  
+
+
+require 'bgp/messages/message'
+
+module BGP
+
+class Route_refresh < Message
+  attr_reader :afi, :safi
+  def initialize(*args)
+    @msg_type=ROUTE_REFRESH
+    if args.size==1  and 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?(Hash)
+      self.afi = args[0][:afi] if args[0][:afi]
+      self.safi = args[0][:safi] if args[0][:safi]
+    else
+      @afi, @safi=args
+    end
+  end
+  
+  def afi=(val)
+    raise ArgumentError, "invalid argument" unless val.is_a?(Fixnum) and (0..0xffff) === val
+    @afi=val
+  end
+  
+  def safi=(val)
+    raise ArgumentError, "invalid argument" unless val.is_a?(Fixnum) and (0..0xff) === val
+    @safi=val
+  end
+  
+  def encode
+    # default to ipv4 and unicast when not set
+    @afi ||=1
+    @safi ||=1
+    super([@afi, 0, @safi].pack('nCC'))
+  end
+  
+  def parse(s)
+    @afi, reserved, @safi= super(s).unpack('nCC')
+  end
+  
+  def to_hash
+    {:afi=> @afi, :safi=> @safi}
+  end
+  
+  def to_s
+    msg = self.encode
+    "Route Refresh (#{ROUTE_REFRESH}), length: #{msg.size}\n" +   "AFI #{IANA.afi(@afi)} (#{@afi}), SAFI #{IANA.safi(@safi)} (#{@safi})"
+  end
+end
+
+#
+#  Carrying ORF Entries in BGP
+#  
+#     ORF entries are carried in the BGP ROUTE-REFRESH message [BGP-RR].
+#  
+#     A BGP speaker can distinguish an incoming ROUTE-REFRESH message that
+#     carries one or more ORF entries from an incoming plain ROUTE-REFRESH
+#     message by using the Message Length field in the BGP message header.
+#
+
+class Orf
+  def self.factory(s)
+    type, len = s.unpack('Cn')
+    case type
+    when ORF::PREFIX 
+      Prefix_orf.new(s.slice!(0,len+3).is_packed)
+    else
+      raise RuntimeError, "orf type #{type} not implemented"
+    end
+  end
+end
+
+#FIXME: Unit-test
+class Orf_route_refresh < Message
+  
+  attr_accessor :orfs
+  
+  def initialize(*args)
+    @msg_type=ROUTE_REFRESH
+    @orfs=[]
+    if args.size==1  and 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?(Hash)
+      self.afi = args[0][:afi] if args[0][:afi]
+      self.safi = args[0][:safi] if args[0][:safi]
+    else
+      @afi, @safi=args
+    end
+  end
+  
+  def afi_to_i
+    @afi
+  end
+  
+  def safi_to_i
+    @safi
+  end
+  
+  def afi
+    IANA.afi(@afi)
+  end
+  
+  def safi
+     IANA.safi(@safi)
+  end
+  
+  def afi=(val)
+    raise ArgumentError, "invalid argument" unless val.is_a?(Fixnum) and (0..0xffff) === val
+    @afi=val
+  end
+  
+  def safi=(val)
+    raise ArgumentError, "invalid argument" unless val.is_a?(Fixnum) and (0..0xff) === val
+    @safi=val
+  end
+  
+  def when_to_s
+    case @when
+    when 1 ; 'defer (1)'
+    when 2 ; 'immediate (2)'
+    else
+      "bogus (#{@when})"
+    end
+  end
+  
+  def encode
+    super([@afi, 0, @safi, @orfs.collect { |o| o.encode }.join].pack('nCCa*'))
+  end
+  
+  def parse(s)
+    @afi, reserved, @safi, orfs= super(s).unpack('nCCa*')
+    while orfs.size>0
+      #puts "orfs before factory: #{orfs.unpack('H*')}"
+      @orfs << Orf.factory(orfs.is_packed)
+      #puts "orfs after factory: #{orfs.unpack('H*')}"
+    end
+  end
+  
+  def to_hash
+    {:afi=> @afi, :safi=> @safi}
+  end
+  
+  def to_s
+    msg = self.encode
+    "ORF Route Refresh (#{ROUTE_REFRESH}), length: #{msg.size}\n" +   
+    "AFI #{IANA.afi(@afi)} (#{@afi}), SAFI #{IANA.safi(@safi)} (#{@safi}):\n" +
+    @orfs.collect { |orf| orf.to_s}.join("\n")
+  end
+  
+  def add(*args)
+    @orfs ||=[]
+    args.each {  |arg| @orfs << arg if arg.is_a?(Orf) }
+  end
+  alias << add
+  
+  def communities
+    @communities.collect { |comm| comm.to_s }.join(' ')
+  end
+  
+end
+
+end

data/bgp/messages/update.rb

@@ -0,0 +1,148 @@
+
+# UPDATE Message Format
+#  
+#     UPDATE messages are used to transfer routing information between BGP
+#     peers.  The information in the UPDATE message can be used to
+#     construct a graph that describes the relationships of the various
+#     Autonomous Systems.  By applying rules to be discussed, routing
+#  
+#  
+#  
+#  Rekhter, et al.             Standards Track                    [Page 14]
+#  
+#  RFC 4271                         BGP-4                      January 2006
+#  
+#  
+#     information loops and some other anomalies may be detected and
+#     removed from inter-AS routing.
+#  
+#     An UPDATE message is used to advertise feasible routes that share
+#     common path Copyright 2008, 2009 to a peer, or to withdraw multiple unfeasible
+#     routes from service (see 3.1).  An UPDATE message MAY simultaneously
+#     advertise a feasible route and withdraw multiple unfeasible routes
+#     from service.  The UPDATE message always includes the fixed-size BGP
+#     header, and also includes the other fields, as shown below (note,
+#     some of the shown fields may not be present in every UPDATE message):
+#  
+#        +-----------------------------------------------------+
+#        |   Withdrawn Routes Length (2 octets)                |
+#        +-----------------------------------------------------+
+#        |   Withdrawn Routes (variable)                       |
+#        +-----------------------------------------------------+
+#        |   Total Path Attribute Length (2 octets)            |
+#        +-----------------------------------------------------+
+#        |   Path Attributes (variable)                        |
+#        +-----------------------------------------------------+
+#        |   Network Layer Reachability Information (variable) |
+#        +-----------------------------------------------------+
+#  
+
+require 'bgp/messages/message'
+require 'bgp/path_attributes/path_attribute'
+
+module BGP
+
+class Update < Message
+  def as4byte?
+    @as4byte ||= false
+  end
+  def initialize(*args)
+    if args[0].is_a?(String) and args[0].is_packed?
+      @as4byte=false
+      parse(*args)
+    elsif args[0].is_a?(self.class)
+      parse(args[0].encode, *args[1..-1])
+    else
+      @msg_type=UPDATE
+      set(*args)
+    end
+  end
+  
+  def set(*args)
+    args.each { |arg|
+      if arg.is_a?(Withdrawn)
+        self.withdrawn=arg
+      elsif arg.is_a?(Path_attribute)
+        self.path_attribute = arg
+      elsif arg.is_a?(Nlri)
+        self.nlri = arg
+      end
+    }
+  end
+  
+  def withdrawn=(val)
+    @withdrawn=val if val.is_a?(Withdrawn)
+  end
+  
+  def nlri=(val)
+    @nlri=val if val.is_a?(Nlri)
+  end
+  
+  def path_attribute=(val)
+    @path_attribute=val if val.is_a?(Path_attribute)
+  end
+  
+  def encode(as4byte=false)
+    @as4byte=as4byte
+    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*'))
+  end
+  
+  def encode4
+    encode(true)
+  end
+  
+  attr_reader :path_attribute, :nlri, :withdrawn
+  
+  # CHANGED ME: NO DEFAULT HERE, the factory calling us has to tell what it is giving us.
+  def parse(s, as4byte=false)
+    @as4byte=as4byte
+    update = super(s)
+    len = update.slice!(0,2).unpack('n')[0]
+    self.withdrawn=Withdrawn.new(update.slice!(0,len).is_packed) if len>0
+    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
+  end
+  
+  def <<(val)
+    if val.is_a?(Attr)
+      @path_attribute ||= Path_attribute.new
+      @path_attribute << val
+    elsif val.is_a?(String)
+      begin 
+        Nlri.new(val)
+        @nlri ||=Nlri.new
+        @nlri << val
+      rescue => e
+      end
+    elsif val.is_a?(Nlri)
+      val.to_s.split.each { |n| self << n }
+    end
+  end
+
+  def to_s(as4byte=@as4byte, fmt=:tcpdump)
+    msg = encode(as4byte)
+    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"
+  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})))
+    elsif u.path_attribute.has?(Mp_reach)
+      pa = Path_attribute.new
+      pa << u.path_attribute[ATTR::MP_REACH].new_unreach
+      Update.new(pa)
+    end
+  end
+end
+
+end

data/bgp/neighbor.rb

@@ -23,6 +23,7 @@
 require 'socket'
 require 'thread'
 require 'observer'
+require 'bgp/io'
 
 module BGP
 
@@ -68,19 +69,22 @@ module BGP
     #  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]
         when :route_refresh, :rr
-          Route_refresh_cap.new(*args[1..-1])
+          OPT_PARM::CAP::Route_refresh.new(*args[1..-1])
         when :mbgp
-          Mbgp_cap.new(*args[1..-1])
+          OPT_PARM::CAP::Mbgp.new(*args[1..-1])
         when :as4_byte, :as4byte, :as4
-          As4_cap.new(@my_as)
+          OPT_PARM::CAP::As4.new(@my_as)
+        when :gr, :graceful_restart
+          OPT_PARM::CAP::Graceful_restart.new(*args[1..-1])
         else
           raise ArgumentError, "Invalid argument #{args.inspect}", caller
         end        
-      elsif args[0].is_a?(Capability)
+      elsif args[0].is_a?(OPT_PARM::Capability)
         args[0]
       else
         raise ArgumentError, "Invalid argument"
@@ -177,10 +181,7 @@ module BGP
         io.start 
         @threads.add io.thread
       }
-      
-      def in  ; @in.thread  ; end
-      def out ; @out.thread ; end
-      
+            
       send_open :ev_send_open
       
       retry_thread if auto_retry == :auto_retry
@@ -206,6 +207,14 @@ module BGP
     end
     alias stop disable
 
+    define_method(:in) do
+      @in.thread
+    end
+    define_method(:out) do
+      @out.thread
+    end
+
+
     def send_message(m)
       raise if m.nil?
       return unless @out
@@ -231,7 +240,7 @@ module BGP
     end
       
     def init_io
-      @in = BGP::IO::Input.new(@socket, @holdtime, self)
+      @in = BGP::IO::Input.new(@socket, holdtime, self)
       @out = BGP::IO::Output.new(@socket, @holdtime, self)
       new_state(:Active, "Open Socket")
     end
@@ -275,7 +284,7 @@ module BGP
       else
         Log.warn "#{self.class}: received open message while in state #{@state}"
       end
-      @as4byte = (open.has?(As4_cap) && o.has?(As4_cap))
+      @as4byte = (open.has?(OPT_PARM::CAP::As4) && o.has?(OPT_PARM::CAP::As4))
     end
     
     def rcv_keepalive
@@ -306,7 +315,7 @@ module BGP
     end
     
     def to_s
-      "version: #{@version}, id: #{@id}, as: #{@my_as}, holdtime: #{@holdtime}, peer addr: #{@remote_addr}, local addr: #{@local_addr}"
+      "version: #{version}, id: #{@id}, as: #{@my_as}, holdtime: #{@holdtime}, peer addr: #{@remote_addr}, local addr: #{@local_addr}"
     end
 
   end

data/bgp/nlris/inet.rb

@@ -0,0 +1,18 @@
+require 'bgp/nlris/prefix'
+
+module BGP
+  class Inet_unicast < Prefix
+    def safi
+      IANA::SAFI::UNICAST_NLRI
+    end
+  end
+
+  class Inet_multicast < Prefix
+    def safi
+      IANA::SAFI::MULTICAST_NLRI
+    end
+  end
+
+end
+
+load "../../test/nlris/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/{label.rb → nlris/label.rb}

@@ -90,5 +90,5 @@ module BGP
   end
 end
 
-load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0
+load "../../test/nlris/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0
 

data/bgp/nlris/labeled.rb

@@ -0,0 +1,39 @@
+require 'bgp/nlris/label'
+module BGP
+  class Labeled
+    def initialize(*args)
+      if args.size>0 and args[0].is_a?(String) and args[0].is_packed?
+        parse(*args)
+      else
+        @prefix, *labels = args
+        @labels = Label_stack.new(*labels)
+      end
+    end
+    def bit_length
+      @labels.bit_length+@prefix.bit_length
+    end
+    def encode
+      [bit_length, @labels.encode, @prefix.encode(false)].pack('Ca*a*')
+    end
+    def to_s
+      "#{@labels} #{@prefix}"
+    end
+    def afi
+      @prefix.afi
+    end  
+    def parse(s, afi=1, safi=1)
+      bitlen = s.slice!(0,1).unpack('C')[0]
+      @labels = Label_stack.new(s)
+      mlen = bitlen - (24*@labels.size)
+      prefix = [mlen,s.slice!(0,(mlen+7)/8)].pack("Ca*")
+      case safi
+      when 128,129
+        @prefix = Vpn.new(prefix)
+      else
+        @prefix = Prefix.new(prefix, afi)
+      end
+    end
+  end
+end
+
+load "../../test/nlris/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/nlris/nlri.rb

@@ -0,0 +1,154 @@
+#--
+# Copyright 2008, 2009 Jean-Michel Esnault.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#
+#
+# This file is part of BGP4R.
+# 
+# BGP4R is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# BGP4R is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with BGP4R.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+
+require 'bgp/common'
+require 'bgp/iana'
+
+module BGP
+
+  class Base_nlri
+
+    class Nlri_element < IPAddr
+      def to_s
+        [super, mlen].join('/')
+      end
+      def encode_next_hop
+        hton
+      end
+      def nbyte
+         (mlen+7)/8
+      end
+      def encode(len_included=true)
+        nbyte = (mlen+7)/8
+        if len_included
+          [mlen, hton].pack("Ca#{nbyte}")
+        else
+          [hton].pack("a#{nbyte}")
+        end
+      end
+      def parse4(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
+      def parse6(arg)
+        s = arg.dup
+        s +=([0]*16).pack('C*')
+        plen, *nlri = s.unpack('Cn8')
+        arg.slice!(0,1+(plen+7)/8) # trim arg accordingly
+        ipaddr = nlri.collect { |n| n.to_s(16) }.join(':') + "/" + plen .to_s
+      end
+    end
+
+    class Ip4 < Nlri_element
+      def initialize(arg)
+        if arg.is_a?(String) and arg.packed?
+          super(parse4(arg))
+        elsif arg.is_a?(Ip4)
+          super(arg.to_s)
+        else
+          super(arg)
+        end
+      end
+    end
+
+    class Ip6 < Nlri_element
+      def initialize(arg)
+        if arg.is_a?(String) and arg.packed?
+          super(parse6(arg))
+        elsif arg.is_a?(Ip6)
+          super(arg.to_s)
+        else
+          super(arg)
+        end
+      end
+    end
+
+    attr_reader :nlris
+
+    def initialize(*args)
+      if args[0].is_a?(String) and args[0].is_packed?
+        parse(args[0])
+      else
+        add(*args)
+      end
+    end
+    def add(*args)
+      @nlris ||=[]
+      args.flatten.each { |arg| @nlris << Ip4.new(arg) }
+    end
+    alias << add
+
+    def parse(s)
+      @nlris ||=[]
+      while s.size>0
+        add(s)
+      end
+    end
+
+    def encode(len_included=false)
+      enc = @nlris.collect { |x| x.encode }.join
+      if len_included
+        [enc.size].pack('n') + enc
+      else
+        enc
+      end
+    end
+
+    def to_s
+      @nlris.join("\n")
+    end
+    
+    def size
+      @nlris.size
+    end
+
+  end
+
+  class Nlri < Base_nlri
+    def encode
+      super
+    end
+  end
+  class Withdrawn < Base_nlri
+    def encode(len_included=true)
+      super(len_included)
+    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)
+      end
+    end
+  end
+
+end
+
+load "../../test/nlris/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/{attributes.rb → nlris/nlris.rb}

@@ -1,5 +1,5 @@
 #--
-# Copyright 2008, 2009 Jean-Michel Esnault.
+# Copyright 2008, 2009, 2010 Jean-Michel Esnault.
 # All rights reserved.
 # See LICENSE.txt for permissions.
 #
@@ -20,15 +20,13 @@
 # along with BGP4R.  If not, see <http://www.gnu.org/licenses/>.
 #++
 
-require 'bgp/origin'
-require 'bgp/next_hop'
-require 'bgp/local_pref'
-require 'bgp/multi_exit_disc'
-require 'bgp/as_path'
-require 'bgp/communities'
-require 'bgp/aggregator'
-require 'bgp/atomic_aggregate'
-require 'bgp/originator_id'
-require 'bgp/cluster_list'
-require 'bgp/mp_reach'
-require 'bgp/extended_communities'
+module BGP
+end
+
+%w{ nlri prefix labeled vpn rd }.each do |n|
+    BGP.autoload  n.capitalize.to_sym,"bgp/nlris/#{n}"
+end
+
+BGP.autoload :Inet_unicast,    "bgp/nlris/inet"
+BGP.autoload :Inet_multicast,  "bgp/nlris/inet"
+BGP.autoload :Withdrawn,       "bgp/nlris/nlri"

data/bgp/nlris/prefix.rb

@@ -0,0 +1,33 @@
+require 'bgp/nlris/nlri'
+module BGP
+  class Prefix < Nlri::Nlri_element
+    def initialize(*args)
+      if args[0].is_a?(String) and args[0].packed?
+        afi = args[1] ||=1
+        case afi
+        when :ip4,1 ; super(parse4(args[0]))
+        when :ip6,2 ; super(parse6(args[0]))
+        end
+      elsif args[0].is_a?(Nlri::Ip4) or args[0].is_a?(Nlri::Ip6) or args[0].is_a?(Prefix)
+        super(args[0].to_s)
+      else
+        super(*args)
+      end
+    end
+    def afi
+      if ipv4?
+        IANA::AFI::IP
+      elsif ipv6?
+        IANA::AFI::IP6
+      end
+    end
+    alias bit_length mlen
+
+    def nexthop
+      to_s.split('/')[0]
+    end
+
+  end
+end
+
+load "../../test/nlris/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/{rd.rb → nlris/rd.rb}

@@ -104,4 +104,4 @@ module BGP
     
   end
 end
-load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0
+load "../../test/path_attributes/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0