bgp4r 0.0.3

data/LICENSE.txt

@@ -0,0 +1,53 @@
+BGP4R is copyrighted free software by Jean-Michel Esnault.  
+
+You can redistribute it and/or modify it under either the terms of the GPL 
+(see the COPYING file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+          modifications to Usenet or an equivalent medium, or by allowing
+          the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+          with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+          together with instructions (in the manual page or equivalent)
+          on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+          the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README.rdoc

@@ -0,0 +1,259 @@
+= BGP4R
+
+== Description
+
+BGP4R is a ruby library which enables the creation and manipulation of BGP messages.
+In BGP4R, all well-known BGP constructs are defined in classes.
+
+Using BGP4R, the process of building BGP messages becomes a simple matter of adding objects 
+to their respective containers; i.e. an attribute is added to a Path_attribute container, 
+while a Path_attribute object or Nlri object is added to an Update object.
+
+= A Neighbor class is used to describe a BGP peering adjacency.
+
+
+==== A Neighbor instance can be started, stopped, and programmed to send BGP messages
+
+  Neighbor#start
+  Neighbor#stop
+  Neighbor#send_message
+
+==== Neighbor capabilities such as MBGP or 4-byte AS can be set using Neighbor#capability
+  
+  e.g.: 
+
+   neighbor = Neighbor.new \
+      :version=> 4, 
+      :my_as=> 100, 
+      :remote_addr => '192.168.1.200', 
+      :local_addr => '192.168.1.5', 
+      :id=> '1.1.1.1', 
+      :holdtime=> 20
+
+   neighbor.capability :as4_byte
+   neighbor.capability :route_refresh
+   neighbor.capability :route_refresh, 128
+   neighbor.capability :mbgp, :ipv4, :unicast
+   neighbor.capability :mbgp, :ipv4, :multicast
+
+
+= Ruby classes representing BGP messages, attributes, and nlri
+
+
+==== Messages:
+
+  Open
+  Update
+  Notification
+  Keepalive
+  Route_refresh
+
+==== Attributes:
+
+  Origin
+  As_path
+  Next_hop
+  Local_pref
+  Multi_exit_disc
+  Communities
+  Atomic_aggregate
+  Aggregator
+  Originator_id
+  Cluster_list
+  Mp_reach
+  Mp_unreach
+  As4_path
+  As4_aggregator
+  Extended_communities
+
+==== Update containers:
+
+  Nlri
+  Path_attribute
+  Withdrawn
+
+= Getting started
+
+=== Here is an example illustrating how to use this API:
+
+  require 'bgp4r'
+  include BGP
+
+==== Start loggin
+
+  Log.create
+  Log.level=Logger::DEBUG
+
+==== Create a Neighbor:
+
+  neighbor = Neighbor.new \
+    :version=> 4, 
+    :my_as=> 100, 
+    :remote_addr => '192.168.1.200', 
+    :local_addr => '192.168.1.5', 
+    :id=> '1.1.1.1', :holdtime=> 20
+
+==== Set its capabilities:
+
+  neighbor.capability :as4_byte
+  neighbor.capability :route_refresh
+  neighbor.capability :route_refresh, 128
+  neighbor.capability :mbgp, :ipv4, :unicast
+  neighbor.capability :mbgp, :ipv4, :multicast
+
+
+==== Start peering:
+
+  neighbor.start :auto_retry
+
+==== Build an BGP Update object made up of a Path_attribute and a Nlri objects:
+
+  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
+
+
+=== Produces:
+    
+    Jean-Michel-Esnaults-MacBook-Pro-17:bgp4r jme$ ruby bgp
+    I, [56:08#28463]  INFO -- : Open Socket old state Idle new state Active
+    I, [56:08#28463]  INFO -- : SendOpen
+    D, [56:08#28463] DEBUG -- : Send Open Message (1), length: 61
+      Version 4, my AS 100, Holdtime 20s, ID 1.1.1.1
+      Capability(65): 4-octet AS number: 100
+      Option Capabilities Advertisement (2): [02020200]
+        Route Refresh (2), length: 2
+      Option Capabilities Advertisement (2): [02028000]
+        Route Refresh (Cisco) (128), length: 2
+      Option Capabilities Advertisement (2): [0206010400010001]
+        Multiprotocol Extensions (1), length: 4
+          AFI IPv4 (1), SAFI Unicast (1)
+      Option Capabilities Advertisement (2): [0206010400010002]
+        Multiprotocol Extensions (1), length: 4
+          AFI IPv4 (1), SAFI Multicast (2)
+      
+    0x0000: ffff ffff ffff ffff ffff ffff ffff ffff
+    0x0001: 003d 0104 0064 0014 0101 0101 2002 0641
+    0x0002: 0400 0000 6402 0202 0002 0280 0002 0601
+    0x0003: 0400 0100 0102 0601 0400 0100
+    
+    
+    D, [56:08#28463] DEBUG -- : #<BGP::IO::Input:0x40ab50> #<Thread:0x40a7b8> started
+    D, [56:08#28463] DEBUG -- : #<BGP::IO::Output:0x40ab14> #<Thread:0x40a754> started
+    I, [56:08#28463]  INFO -- : ev_send_open old state Active new state OpenSent
+    I, [56:08#28463]  INFO -- : RecvOpen
+    D, [56:08#28463] DEBUG -- : Recv Open Message (1), length: 61
+      Version 4, my AS 100, Holdtime 180s, ID 2.2.2.2
+      Option Capabilities Advertisement (2): [0206010400010001]
+        Multiprotocol Extensions (1), length: 4
+          AFI IPv4 (1), SAFI Unicast (1)
+      Option Capabilities Advertisement (2): [0206010400010002]
+        Multiprotocol Extensions (1), length: 4
+          AFI IPv4 (1), SAFI Multicast (2)
+      Option Capabilities Advertisement (2): [02028000]
+        Route Refresh (Cisco) (128), length: 2
+      Option Capabilities Advertisement (2): [02020200]
+        Route Refresh (2), length: 2
+      Capability(65): 4-octet AS number: 100
+      
+    0x0000: ffff ffff ffff ffff ffff ffff ffff ffff
+    0x0001: 003d 0104 0064 00b4 0202 0202 2002 0601
+    0x0002: 0400 0100 0102 0601 0400 0100 0202 0280
+    0x0003: 0002 0202 0002 0641 0400 0000
+    
+    
+    I, [56:08#28463]  INFO -- : RecvOpen old state OpenSent new state OpenConfirm
+    I, [56:08#28463]  INFO -- : RecvKeepalive
+    D, [56:08#28463] DEBUG -- : Recv Keepalive Message (4), length: 19, [001304]
+    
+    I, [56:08#28463]  INFO -- : SendKeepalive
+    D, [56:08#28463] DEBUG -- : Send Keepalive Message (4), length: 19, [001304]
+    
+    D, [56:08#28463] DEBUG -- : SendKeepAlive
+    I, [56:08#28463]  INFO -- : RecvKeepAlive old state OpenConfirm new state Established
+    I, [56:08#28463]  INFO -- : RecvKeepalive
+    D, [56:08#28463] DEBUG -- : Recv Keepalive Message (4), length: 19, [001304]
+    
+    I, [56:08#28463]  INFO -- : version: 4, id: 1.1.1.1, as: 100, holdtime: 20, peer addr: 192.168.1.200, local addr: 192.168.1.5 started
+    I, [56:08#28463]  INFO -- : SendUpdate
+    D, [56:08#28463] DEBUG -- : Send Update Message (2), 4 bytes AS, length: 92
+      Path Attributes:
+      Origin (1), length: 1, Flags [T]: incomplete
+       0x0000: 
+      Next Hop (3), length: 4, Flags [T]: 192.168.1.5
+       0x0000: c0a8 0105
+      Multi Exit Disc (4), length: 4, Flags [O]: (0x0064) 100
+       0x0000: 0000 0064
+      Local Pref (5), length: 4, Flags [T]: (0x0064) 100
+       0x0000: 0000 0064
+      As Path (2), length: 14, Flags [T]: 400 300 200
+       0x0000: 0203 0000 0190 0000 012c 0000 00c8
+      Communities (8), length: 12, Flags [OT]: 1311:1 311:59 2805:64
+       0x0000: 051f 0001 0137 003b 0af5 0040
+    77.0.0.0/17
+    78.0.0.0/18
+    79.0.0.0/19
+    
+    0x0000: ffff ffff ffff ffff ffff ffff ffff ffff
+    0x0001: 005c 0200 0000 3940 0101 0240 0304 c0a8
+    0x0002: 0105 8004 0400 0000 6440 0504 0000 0064
+    0x0003: 4002 0e02 0300 0001 9000 0001 2c00 0000
+    0x0004: c8c0 080c 051f 0001 0137 003b 0af5 0040
+    0x0005: 114d 0000 124e 0000 134f 0000
+    
+    
+    I, [56:13#28463]  INFO -- : RecvKeepalive
+    D, [56:13#28463] DEBUG -- : Recv Keepalive Message (4), length: 19, [001304]
+    
+    I, [56:14#28463]  INFO -- : SendKeepalive
+    D, [56:14#28463] DEBUG -- : Send Keepalive Message (4), length: 19, [001304]
+
+
+== Source Code
+
+Source code is hosted on github.
+
+== Installation
+
+==== Run the following if you haven't already: 
+
+  gem sources -a http://gems.github.com
+
+==== Install the gem
+
+  sudo gem install jesnault-bgp4r
+
+=== Or clone bgp4r tree and set RUBYLIB env variable accordingly:
+
+  git clone git://github.com/jesnault/bgp4r.git
+  export RUBYLIB=/home/user/bgp4r
+
+== Requirements
+
+
+== License
+
+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/>.

data/bgp/aggregator.rb

@@ -0,0 +1,104 @@
+#--
+# 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/attribute'
+
+module BGP
+
+  class Aggregator < Attr
+
+    def initialize(*args)
+      @flags, @type, @as4byte =OPTIONAL_TRANSITIVE, AGGREGATOR, false
+      if args[0].is_a?(String) and args[0].is_packed?
+        parse(*args)
+      elsif args.size==2 and
+        args[0].is_a?(String) and (args[1].is_a?(Fixnum) or args[1].is_a?(Bignum))
+        @ip_address = IPAddr.create(args[0])
+        @as = args[1]
+      elsif args[0].is_a?(self.class)
+        parse(args[0].encode, *args[1..-1])
+      else
+        raise ArgumentError, "invalid argument, #{args.inspect}"
+      end
+    end
+
+    def address=(val)
+      @ip_address=IPAddr.create(val)
+    end
+
+    def address
+      @ip_address.to_s
+    end
+
+    def as(sep='')
+      case sep
+      when '.'
+        has = @as >> 16
+        las = @as & 0xffff
+        [has,las].join('.')
+      else
+        @as
+      end
+    end
+    
+    def aggregator(as4byte=@as4byte)
+      "#{address}, #{as(as4byte ? '.':'')}"
+    end
+    
+    def to_s(method=:default)
+      super(aggregator, method)
+    end
+    
+    def parse(s,as4byte=false)
+      @flags, @type, len, @as, addr = super(s, as4byte ? 'NN' : 'nN')
+      self.address = addr
+    end
+    
+    def encode(as4byte=@as4byte)
+      f = as4byte ? 'N' : 'n'
+      super([@as].pack(f) + @ip_address.hton)
+    end
+    
+  end
+
+  class As4_aggregator < Aggregator
+    def initialize(*args)
+      super(*args)
+      @flags, @type, @as4byte =OPTIONAL_TRANSITIVE, AS4_AGGREGATOR, true
+    end
+    def parse(s,as4byte=@as4byte)
+      super(s,true)
+    end
+    def encode(as4byte=@as4byte)
+      f = as4byte ? 'N' : 'n'
+      super([@as].pack(f) + @ip_address.hton)
+    end
+
+    def aggregator(as4byte=@as4byte)
+      super(true)
+    end
+
+  end
+
+end
+
+load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/as_path.rb

@@ -0,0 +1,223 @@
+#--
+# 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/attribute'
+
+module BGP
+    
+    class As_path < Attr
+      
+      ##############################
+      
+      class Segment
+        include ATTR
+        
+        def self.factory(s, as4byte=false)
+          seg_type, num = s.slice(0,2).unpack('CC')
+          len = num * (as4byte ? 4 : 2)+2
+          segment = s.slice!(0, len).is_packed
+          case seg_type
+          when SET ; Set.new(segment, as4byte)
+          when SEQUENCE ; Sequence.new(segment, as4byte)
+          when CONFED_SEQUENCE ; Confed_sequence.new(segment, as4byte)
+          when CONFED_SET ; Confed_set.new(segment, as4byte)
+          end
+        end
+        
+        attr_reader :as
+        
+        def initialize(seg_type, *args)
+          @as=[]
+          if seg_type.is_a?(String) and seg_type.is_packed?
+            parse(seg_type, *args)
+          elsif args.size>0 and args.is_a?(Array)
+            self.seg_type = seg_type
+            @as = args
+          else
+            raise ArgumentError, "invalid argument #{args.inspect}"
+          end
+          
+        end
+        
+        def seg_type
+          @seg_type
+        end
+        
+        def seg_type=(val)
+          case val
+          when :set             ; @seg_type = SET
+          when :sequence        ; @seg_type = SEQUENCE
+          when :confed_sequence ; @seg_type = CONFED_SEQUENCE
+          when :confed_set      ; @seg_type = CONFED_SET
+          else
+            raise ArgumentError, "invalid segment type #{val.class} #{val}"
+          end
+        end
+        
+        def encode(as4byte=false)
+          [@seg_type, @as.size, @as].flatten.pack("CC#{as4byte ? 'N' : 'n'}*")
+        end
+        
+        def as4byte?
+          defined?(@as4byte) and @as4byte
+        end
+        
+        def parse(s, as4byte=false)
+          @seg_type, skip, *@as = s.unpack("CC#{as4byte ? 'N' : 'n'}*")
+          @as = [@as].flatten
+        end
+        
+        def to_s
+          case @seg_type
+          when SET             ; s = "{" ; join=", "
+          when SEQUENCE        ; s = ""  ; join= " "
+          when CONFED_SET      ; s = "[" ; join= ", "
+          when CONFED_SEQUENCE ; s = "(" ; join= " "
+          else ; s = "?("
+          end
+          s += @as.join(join)
+          case @seg_type
+          when SET             ; s += "}"
+          when CONFED_SET      ; s += "]"
+          when CONFED_SEQUENCE ; s += ")"
+          when SEQUENCE
+          else ; s += ")"
+          end
+          s
+        end
+        
+      end
+      
+      class As_path::Set < As_path::Segment
+        def initialize(*args)
+          if args[0].is_a?(String)
+            super(*args)
+          else
+            super(:set, *args)
+          end
+        end
+      end
+      
+      class As_path::Sequence < As_path::Segment
+        def initialize(*args)
+          if args[0].is_a?(String)
+            super(*args)
+          else
+            super(:sequence, *args)
+          end
+        end
+      end
+      
+      class As_path::Confed_set < As_path::Segment
+        def initialize(*args)
+          if args[0].is_a?(String)
+            super(*args)
+          else
+            super(:confed_set, *args)
+          end
+        end
+      end
+      
+      class As_path::Confed_sequence < As_path::Segment
+        def initialize(*args)
+          if args[0].is_a?(String)
+            super(*args)
+          else
+            super(:confed_sequence, *args)
+          end
+        end
+      end
+      
+      ##############################
+      
+      def integer?(arg)
+        arg.is_a?(Fixnum) or arg.is_a?(Bignum)
+      end
+      
+      attr_accessor :as4byte
+      
+      def initialize(*args)
+
+        @flags, @type, @segments, @as4byte = WELL_KNOWN_MANDATORY, AS_PATH, [], false
+        
+        if args[0].is_a?(String) and args[0].is_packed?
+          parse(*args)
+        elsif args[0].is_a?(self.class)
+          parse(args[0].encode, *args[1..-1])
+        elsif integer?(args[0])
+          @segments << Sequence.new(*args.dup)
+        elsif args[0].is_a?(Segment)
+          unless args.find { |seg| ! seg.is_a?(Segment) }.nil?
+            raise ArgumentError, "at least one arg is not a segment"
+          end
+          @segments = args.dup
+        end
+        
+      end
+      
+      def <<(val)
+        raise ArgumentError, "invalid argument, #{val.class} #{val}" unless val.is_a?(Segment)
+        @segments << val
+      end
+      
+      def encode(as4byte=@as4byte)
+        super(@segments.collect { |segment| segment.encode(as4byte) }.join)
+      end
+      
+      def encode4
+        encode(true)
+      end
+      
+      def as_path
+        return 'empty' if @segments.empty?
+        @segments.collect { |seg| seg.to_s }.join(' ')
+      end
+      
+      def to_s(method=:default, as4byte=false)
+        super(as_path, method, as4byte)
+      end
+      
+      private
+      
+      def parse(s,as4byte=false)
+        @flags, @type, len, value=super(s)
+        while value.size>0
+          @segments << Segment.factory(value.is_packed, as4byte)
+        end
+      end
+      
+    end
+    
+    class As4_path < As_path
+      def initialize(*args)
+        super(*args)
+        @flags, @type, @as4byte =OPTIONAL_TRANSITIVE, AS4_PATH, true        
+      end
+      def parse(s,as4byte=@as4byte)
+        super(s,true)
+      end
+    end
+    
+end
+
+load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0
+

data/bgp/atomic_aggregate.rb

@@ -0,0 +1,42 @@
+#--
+# 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/attribute'
+
+module BGP
+
+  class Atomic_aggregate < Attr
+    def initialize(arg=nil)
+      @flags, @type=OPTIONAL, ATOMIC_AGGREGATE
+      if arg.is_a?(String) and arg.is_packed?
+        parse(arg)
+      elsif arg.nil?
+      else
+        raise ArgumentError, "invalid argument, #{arg.class} #{arg}"
+      end
+    end
+  end
+
+end
+
+load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0