bgp4r 0.0.3

data/bgp/path_attribute.rb

@@ -0,0 +1,210 @@
+#--
+# 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/attributes'
+
+module BGP
+
+  class Path_attribute
+    include BGP::ATTR
+    def initialize(*args)
+      if args.size <= 2 and args[0].is_a?(String) and args[0].is_packed?
+        s = args[0]
+        @attributes=[]
+        while s.size>0
+          @attributes << Attr.factory(s)
+        end
+      else
+        add(*args)
+      end
+    end
+    def add(*args)
+      @attributes ||=[]
+      args.each { |arg| @attributes << arg if arg.is_a?(BGP::Attr) }
+      self
+    end
+    alias << add
+    
+    def to_ary
+      @attributes
+    end
+    
+    def to_s(method=:default,as4byte=false)
+      "Path Attributes:" + ([""] + @attributes.collect { |a|
+        if as4byte and a.is_a?(As_path)
+          a.to_s(method, as4byte)
+        else
+          a.to_s(method)
+        end
+      }).join("\n  ")
+    end
+    
+    def find(klass)
+      @attributes.find { |a| a.is_a?(klass) }
+    end
+    
+    def size
+      @attributes.size
+    end
+    
+    def [](type)
+      case type
+      when  ORIGIN, :origin
+        find(Origin)
+      when  AS_PATH, :as_path
+        find(As_path)
+      when  NEXT_HOP, :next_hop
+        find(Next_hop)
+      when  MULTI_EXIT_DISC, :multi_exit_disc
+        find(Multi_exit_disc)
+      when  LOCAL_PREF, :local_pref
+        find(Local_pref)
+      when  ATOMIC_AGGREGATE, :atomic_aggregate
+        find(Atomic_aggregate)
+      when  AGGREGATOR, :aggregator
+        find(Aggregator)
+      when  COMMUNITIES, :communities
+        find(Communities)
+      when ORIGINATOR_ID, :originator_id
+        find(Originator_id)
+      when CLUSTER_LIST, :cluster_list
+        find(Cluster_list)
+      when MP_REACH, :mp_reach
+        find(Mp_reach)
+      when MP_UNREACH, :mp_unreach
+        find(Mp_unreach)
+      when EXTENDED_COMMUNITY, :extended_community
+        find(Extended_communities)
+      when AS4_PATH, :as4_path
+        find(As4_path)
+      when AS4_AGGREGATOR, :as4_aggregator
+        find(As4_aggregator)
+      end
+    end
+    
+    def has?(klass=nil)
+      if klass
+        @attributes.find { |a| a.is_a?(klass) }.nil? ? false : true
+      else
+        @attributes.collect { |attr| attr.class }
+      end
+    end
+    
+    def encode(as4byte=false)
+      [@attributes.compact.collect { |x| as4byte ? x.encode4 : x.encode }.join].pack('a*')
+    end
+    
+    def insert(*args)
+      for arg in args
+        next unless arg.is_a?(Attr)
+        to_ary.insert(0,arg)
+      end
+      self
+    end
+    
+    def append(*args)
+      for arg in args
+        next unless arg.is_a?(Attr)
+        to_ary << (arg)
+      end
+      self
+    end
+    
+    def replace(*args)
+      for arg in args
+        next unless arg.is_a?(Attr)
+        attr = to_ary.find { |x| x.class == arg.class }
+        if attr.nil?
+          append(arg)
+        else
+          index = to_ary.index(attr)
+          to_ary[index] = arg
+        end
+      end
+      self
+    end
+    
+    def delete(*klasses)
+      for klass in klasses
+        next unless klass.is_a?(Class)
+        to_ary.delete_if { |x| x.class == klass }
+      end
+      self
+    end
+    
+  end
+  
+end
+
+module BGP
+
+  class Attr
+    include BGP::ATTR
+    def self.factory(s)
+      flags, type = s.unpack('CC')
+      case type
+      when ORIGIN
+        Origin.new(s)
+      when AS_PATH
+        As_path.new(s)
+      when NEXT_HOP
+        Next_hop.new(s)
+      when MULTI_EXIT_DISC
+        Multi_exit_disc.new(s)
+      when LOCAL_PREF
+        Local_pref.new(s)
+      when ATOMIC_AGGREGATE
+        Atomic_aggregate.new(s)
+      when AGGREGATOR
+        Aggregator.new(s)
+      when COMMUNITIES
+        Communities.new(s)
+      when ATOMIC_AGGREGATE
+        Atomic_aggregate.new(s)
+      when ORIGINATOR_ID
+        Originator_id.new(s)
+      when CLUSTER_LIST
+        Cluster_list.new(s)
+      when MP_REACH
+        Mp_reach.new(s)
+      when MP_UNREACH
+        Mp_unreach.new(s)
+      when EXTENDED_COMMUNITY
+        Extended_communities.new(s)
+      else
+        if flags & 0x10==1
+          len = s.slice!(0,2).unpack("n")[0]
+        else 
+          len = s.slice!(0,1).unpack('C')[0]
+        end
+        s.slice!(0,len)
+        raise RuntimeError, "factory for #{type} to be implemented soon"
+        nil
+      end
+    end
+
+  end
+  
+end
+
+load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/prefix_orf.rb

@@ -0,0 +1,263 @@
+#--
+# 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/nlri'
+require 'bgp/orf'
+
+module BGP
+  
+  class Prefix_entry < Orf::Entry
+  
+    @_seqn_ = -10
+    class << self
+      attr_accessor :_seqn_ 
+      def seqn ; Address_prefix_orf_entry._seqn_ +=10 ;end
+    end
+
+    def initialize(*args)
+      if args[0].is_a?(String) and args[0].is_packed?
+        _parse_(*args)
+      elsif args.size==6
+        @action, @match, @seqn, @min, @max, prefix = args
+        @prefix = BGP::Prefix.new(prefix) 
+      elsif args.size==4
+        @min, @max = 0, 0
+        @action, @match, @seqn, prefix = args
+        @prefix = BGP::Prefix.new(prefix) 
+      elsif args.size==1 and args[0].is_a?(Hash)
+        set(args[0])
+      else
+        p args
+        raise
+      end
+    end
+    
+    def action=(val)
+      case val
+      when 0, :add
+        @action=0
+      when 1, :remove
+        @action=1
+      when 2, :remove_all
+        @action=2
+      end
+    end
+    
+    def action_to_i
+      @action
+    end
+
+    def action_to_s
+      case @action
+      when 0 ; 'add'
+      when 1 ; 'remove'
+      when 2 ; 'remove all'
+      else
+        'unknown action'
+      end
+    end
+    
+    def match_to_i
+      @match
+    end
+
+    def match_to_s
+      case @match
+      when 0 ; 'permit'
+      when 1 ; 'deny'
+      end
+    end
+
+    def match=(val)
+      case val
+      when 0, :permit ; @match=0
+      when 1, :deny   ; @match=1
+      else
+        raise
+      end
+    end
+    
+    def set(h)
+      self.action = h[:action] ||= 0
+      self.match = h[:match] ||= 0
+      @seqn = h[:seqn] ||= 0
+      @min = h[:min] ||= 0
+      @max = h[:max]  ||= 0
+      @prefix = BGP::Prefix.new(h[:prefix]) if h[:prefix]
+    end
+
+    def encode
+      [_first_octet_,@seqn, @min, @max, @prefix.encode(true)].pack('CNCCa*')
+    end
+    
+    def to_s
+       #FIXME unit-test
+       s = format("seq %3s %6s %s", @seqn, action_to_s, @prefix)
+       s += " ge #{@min}" if @min>0
+       s += " le #{@max}" if @max>0
+       s +=  " #{match_to_s}"
+       s
+    end
+      
+    private
+    
+    def _first_octet_
+      (@action<<6) | ((@match & 0x1) << 5)
+    end
+    
+    def size
+      @prefix.nbyte+7+1    
+    end
+    
+    def _parse_(s, afi=1)
+      #puts "s before parse: #{s.unpack('H*')}"
+      o1, @seqn, @min, @max, prefix = s.unpack('CNCCa*')
+      @action = o1 >> 6
+      @match = (o1 >> 5) & 1
+      @prefix = BGP::Prefix.new(prefix.is_packed, afi)
+      #puts "size of orf entry is : #{size}"
+      s.slice!(0,size)
+      #puts "s after parse: #{s.unpack('H*')}"
+    end
+
+    def self.add(*args) ; Prefix_entry.new(0,*args)  ; end
+    def self.add_and_deny(*args) ; Prefix_entry.new(0,1,*args) ; end
+    def self.add_and_permit(*args) ; Prefix_entry.new(0,0,*args) ; end
+    def self.remove(*args) ; Prefix_entry.new(1,*args)  ; end
+    def self.remove_and_deny(*args) ; Prefix_entry.new(1,1,*args) ; end
+    def self.remove_and_permit(*args) ; Prefix_entry.new(1,0,*args) ; end
+    def self.remove_all(*args) ; Prefix_entry.new(2,0) ; end
+
+  end
+    
+end
+
+class BGP::Prefix_orf < BGP::Orf
+    
+  def initialize(*args)
+    if args[0].is_a?(String) and args[0].is_packed?
+      _parse_(*args)
+    elsif args[0].is_a?(self.class) and args[0].respond_to?(:encode)
+      _parse_(args[0].encode)
+    else
+      super(64, *args)
+    end
+  end
+  
+  def add(e)
+    raise ArgumentError, "invalid argument" unless e.is_a?(BGP::Prefix_entry)
+    super(e)
+  end
+
+  def _parse_(s)
+    @entries=[]
+    @type, len, entries = s.unpack('Cna*')
+    while entries.size>0
+      #p entries.unpack('H*')
+      @entries << BGP::Prefix_entry.new(entries.is_packed)
+    end
+  end
+  
+  def cisco_prefix_entry_type
+    @type=130
+  end  
+
+end
+
+load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0
+
+__END__
+
+
+  2. Address Prefix ORF-Type
+
+     The Address Prefix ORF-Type allows one to express ORFs in terms of
+     address prefixes. That is, it provides address prefix based route
+     filtering, including prefix length or range based matching, as well
+     as wild-card address prefix matching.
+
+     Conceptually an Address Prefix ORF entry consists of the fields
+     <Sequence, Match, Length, Prefix, Minlen, Maxlen>.
+
+     The "Sequence" field specifies the relative ordering of the entry
+     among all the Address Prefix ORF entries.
+
+     The "Match" field specifies whether this entry is "PERMIT" (value 0),
+     or "DENY" (value 1).
+
+     The "Length" field indicates the length in bits of the address
+     prefix. A length of zero indicates a prefix that matches all (as
+     specified by the address family) addresses (with prefix itself of
+     zero octets).
+
+     The "Prefix" field contains an address prefix of an address family.
+
+     The "Minlen" field indicates the minimum prefix length in bits that
+     is required for "matching". The field is considered as un-specified
+     with value 0.
+
+     The "Maxlen" field indicates the maximum prefix length in bits that
+     is required for "matching". The field is considered as un-specified
+     with value 0.
+
+     The fields "Sequence", "Length", "Minlen", and "Maxlen" are all
+     unsigned integers.
+
+     This document imposes the following requirement on the values of
+     these fields:
+
+             0 <= Length < Minlen <= Maxlen
+
+     In addition, the "Maxlen" must be no more than the maximum length (in
+     bits) of a host address for a given address family [BGP-MP].
+
+
+  3. Address Prefix ORF Encoding
+
+     The value of the ORF-Type for the Address Prefix ORF-Type is 64.
+
+     An Address Prefix ORF entry is encoded as follows. The "Match" field
+     of the entry is encoded in the "Match" field of the common part [BGP-
+     ORF], and the remaining fields of the entry is encoded in the "Type
+     specific part" as shown in Figure 1.
+
+
+                 +--------------------------------+
+                 |   Sequence (4 octets)          |
+                 +--------------------------------+
+                 |   Minlen   (1 octet)           |
+                 +--------------------------------+
+                 |   Maxlen   (1 octet)           |
+                 +--------------------------------+
+                 |   Length   (1 octet)           |
+                 +--------------------------------+
+                 |   Prefix   (variable length)   |
+                 +--------------------------------+
+
+                Figure 1: Address Prefix ORF Encoding
+
+
+     Note that the Prefix field contains the address prefix followed by
+     enough trailing bits to make the end of the field fall on an octet
+     boundary.  The value of the trailing bits is irrelevant.
+

data/bgp/rd.rb

@@ -0,0 +1,107 @@
+#--
+# 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'
+module BGP
+  class Rd
+    attr_reader :admin, :assign
+    def bit_length ; 64 ; end
+    def initialize(*args)
+      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.empty?
+        @enc_type, @admin, @assign = [0]*3
+      elsif args.size==3
+        admin, assign, @enc_type = args
+        case @enc_type
+        when 0
+          @admin, @assign,@enc_type = admin, assign, 0
+        when 1
+          @enc_type = 1
+          @admin = IPAddr.new(admin)
+          @assign = assign
+        when 2
+          @admin, @assign, @enc_type,  = admin, assign, 2
+        end
+      elsif args.size==2
+        admin, assign = args
+        if admin.is_a?(String)
+          @admin, @assign, @enc_type = IPAddr.new(admin), assign, 1
+        elsif assign.is_a?(String)
+          @admin, @assign, @enc_type,  = admin, IPAddr.new(assign).to_i, 2
+        else
+          @admin, @assign, @enc_type,  = admin, assign, 0
+        end
+      end
+    end
+
+    def encode
+      case @enc_type
+      when 0
+        [@enc_type, @admin, @assign].pack('nnN')
+      when 1
+        [@enc_type, @admin.hton, @assign].pack('na*n')
+      when 2
+        [@enc_type, @admin, @assign].pack('nNn')
+      end
+    end
+
+    def parse(s)
+      case s[0,2].unpack('n')[0]
+      when 0
+        @enc_type, @admin, @assign = s.unpack('nnN')
+      when 1
+        @enc_type, admin, @assign = s.unpack('na4n')
+        @admin = IPAddr.new_ntoh(admin)
+      when 2
+        @enc_type, @admin, @assign = s.unpack('nNn')
+      else
+        puts "Bogus rd ? #{s.unpack('H*')}"
+      end
+    end
+
+    def to_s(verbose=true)
+      if verbose
+        case @enc_type
+        when 0 ; format "RD=%d:%d (0x%02x 0x%04x)", @admin, @assign, @assign, @assign
+        when 1 ; format "RD=%s:%d (0x%04x 0x%02x)", @admin, @assign, @admin.to_i, @assign
+        when 2 ; format "RD=%d:%d (0x%04x 0x%02x)", @admin, @assign, @admin, @assign
+        end
+      else
+        case @enc_type
+        when 0 ; format "RD=%d:%d", @admin, @assign
+        when 1 ; format "RD=%s:%d", @admin, @assign
+        when 2 ; format "RD=%d:%d", @admin, @assign
+        end
+      end
+    end
+    
+    def encoding_type?
+      @enc_type
+    end
+    
+  end
+end
+load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/examples/bgp

@@ -0,0 +1,65 @@
+#--
+#
+# Copyright 2008, 2009 Jean-Michel Esnault.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#
+#++
+
+require 'bgp4r'
+include BGP
+
+# Start loggin
+Log.create
+Log.level=Logger::DEBUG
+
+# Create a neighbor and set optional capabilities.
+neighbor = Neighbor.new \
+  :version=> 4, 
+  :my_as=> 100, 
+  :remote_addr => '192.168.1.199', 
+  :local_addr => '192.168.1.5', 
+  :id=> '1.1.1.1', :holdtime=> 180
+
+neighbor.capability :as4_byte
+neighbor.capability :route_refresh
+neighbor.capability :route_refresh, 128
+neighbor.capability :mbgp, :ipv4, :unicast
+neighbor.capability :mbgp, :ipv4, :multicast
+
+# A call back to handle received messages we are interested in.
+def self.update(msg)
+  case msg.class.to_s
+  when /Notification/
+    Log.warn "Going down !"
+  # Ignore uninterested ones.
+  # when /Open/
+  # when /Keepalive/
+  when /Update/
+    Log.info "RecvUpdate\n#{m}"
+  end
+end
+
+neighbor.add_observer(self)
+
+# Start peering (will block til the session is established)
+neighbor.start :auto_retry
+
+# An BGP Update object
+an_update = Update.new(
+  Path_attribute.new(
+    Origin.new(2),
+    Next_hop.new('192.168.1.5'),
+    Multi_exit_disc.new(100),
+    Local_pref.new(100),
+    As_path.new(400,300,200),
+    Communities.new('1311:1 311:59 2805:64')
+  ),
+  Nlri.new('77.0.0.0/17', '78.0.0.0/18', '79.0.0.0/19')
+)
+
+# Ship it!
+neighbor.send_message an_update
+
+# Keep session up.
+Thread.stop