jesnault-bgp4r 0.0.2 → 0.0.3

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

data/bgp/attribute.rb

@@ -0,0 +1,181 @@
+#--
+# 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
+  
+  module ATTR
+    
+    ### http://www.iana.org/assignments/bgp-parameters/bgp-parameters.xhtml#bgp-parameters-2
+    
+    ORIGIN = 1
+    AS_PATH = 2
+    NEXT_HOP = 3
+    MULTI_EXIT_DISC = 4
+    LOCAL_PREF = 5
+    ATOMIC_AGGREGATE = 6
+    AGGREGATOR = 7
+    COMMUNITIES = 8
+    ORIGINATOR_ID = 9
+    CLUSTER_LIST = 10
+    
+    MP_REACH = 14
+    MP_UNREACH = 15
+    EXTENDED_COMMUNITY = 16
+    AS4_PATH = 17
+    AS4_AGGREGATOR = 18
+    
+    SET = 1
+    SEQUENCE = 2
+    CONFED_SEQUENCE = 3
+    CONFED_SET = 4
+    
+    OPTIONAL = 0x8
+    TRANSITIVE = 0x4
+    PARTIAL = 0x2
+    EXTENDED_LENGTH = 0x1 
+    NONE = 0x0
+    
+    WELL_KNOWN_MANDATORY     = TRANSITIVE
+    WELL_KNOWN_DISCRETIONARY = TRANSITIVE
+    OPTIONAL_TRANSITIVE      = OPTIONAL | TRANSITIVE
+    OPTIONAL_NON_TRANSITIVE  = OPTIONAL
+    
+    def encode(value='',value_fmt=nil)
+      len, len_fmt = value.size, 'C'
+      if len>255
+        @flags |= EXTENDED_LENGTH
+        len_fmt='n'
+      end
+      if value_fmt
+        [@flags<<4, @type, len, *value].pack("CC#{len_fmt}#{value_fmt}")
+      else
+        ([@flags<<4, @type, len].pack("CC#{len_fmt}") + value).is_packed
+      end
+    end
+    
+    def parse(*args)
+      _parse_(*args)
+    end
+    
+    def _parse_(s,vf=nil)
+      value, arr = '', []
+      flags = s.unpack('C')[0]
+      if flags & 0x10>0
+        arr = s.unpack("CCn")
+        len = arr[2]
+        if vf
+          value = s[4..-1].unpack(vf)
+        else
+          value = s[4..-1].unpack("a#{len}")
+        end
+        s.slice!(0,arr[2]+4).is_packed
+      else
+        arr = s.unpack("CCC")
+        len = arr[2]
+        if vf
+          value = s[3..-1].unpack(vf)
+        else
+          value = s[3..-1].unpack("a#{len}")
+        end
+        s.slice!(0,arr[2]+3).is_packed
+      end
+      arr[0]= arr[0] >>4
+      value[0].is_packed unless vf
+      arr + value
+    end
+    
+    def name
+      self.class.to_s.split('::').last
+    end
+    
+    def flags
+      flags = @flags
+      s ="["
+      (flags&8>0) ? s +="O" : s += "w"
+      (flags&4>0) ? s +="T" : s += "n"
+      (flags&2>0) ? s +="P" : s += "c"
+      (flags&1>0) ? s +="E" : s += "r"
+      s +="]"
+    end
+    
+    def flags_short
+      flags = @flags
+      s ="["
+      s +="O" if (flags&8>0)
+      s +="T" if (flags&4>0)
+      s +="P" if (flags&2>0)
+      s +="E" if (flags&1>0)
+      s +="]"
+    end
+    
+    def attribute_name
+      name.split('_').collect { |w| w.capitalize }.join(' ')
+    end
+    
+    def to_s(value='', mode=:tcpdump, as4byte=false)
+      
+      shex = as4byte ? to_shex4_len(20) : to_shex_len(20)
+      
+      mode = :brief unless [:tcpdump, :brief, :hexlify].include?(mode)
+      
+      case mode
+      when :brief
+        sprintf "%s %4s %10s: [%s]%s", flags, "(#{@type})", attribute_name, shex, "#{value.size>0 ? " '#{value}'" :''}"
+      when :hexlify
+        s = sprintf "%s %4s %10s: [%s]%s", flags, "(#{@type})", attribute_name, shex, "#{value.size>0 ? " '#{value}" :''}"
+        s +="\n\n"
+        if as4byte
+          s += self.encode4.hexlify.join("\n")
+        else
+          s += self.encode.hexlify.join("\n")
+        end
+      when :tcpdump
+        if as4byte
+          f, t, len, enc_value = _parse_(self.encode4, nil)
+        else
+          f, t, len, enc_value = _parse_(self.encode, nil)
+        end
+        s = sprintf "%s (%d), length: %d, Flags %s: %s", attribute_name, @type, len, flags_short, value
+        s += enc_value.hexlify.join(("\n   "))
+      end
+    end
+    
+  end
+
+  class Attr
+    
+    include ATTR
+    include Comparable
+    
+    def method_missing(name, *args, &block)
+      if name == :encode4
+        send :encode, *args, &block
+      else
+        super
+      end
+    end 
+
+  end
+
+end

data/bgp/attributes.rb

@@ -0,0 +1,34 @@
+#--
+# 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/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'

data/bgp/cluster_list.rb

@@ -0,0 +1,117 @@
+#--
+# 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 Cluster_list < Attr
+
+    ##########################################################
+    # CLUSTER ID                                             #
+    ##########################################################
+    class Id
+      def initialize(id)
+        @id = IPAddr.create(id)
+      end
+      def to_s
+        @id.to_s
+      end
+      def to_i
+        @id.to_i
+      end
+      def encode
+        @id.hton
+      end
+    end
+
+    ##########################################################
+    # CLUSTER_LIST ATTRIBUTE                                 #
+    ##########################################################
+
+    def initialize(*args)
+      @flags, @type = OPTIONAL, CLUSTER_LIST
+      if 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])
+      else
+        add(*args)
+      end
+    end
+
+    def add(*args)
+      @cluster_ids ||=[]
+      args.flatten.each do |arg|
+        if arg.is_a?(String) and arg.split(' ').size>1
+          arg.split.each { |v| @cluster_ids << Id.new(v) }
+        elsif arg.is_a?(String) and arg.split(',').size>1
+          arg.split(',').each { |v| @cluster_ids << Id.new(v) }
+        elsif arg.is_a?(Id)
+          @cluster_ids << arg
+        else
+          @cluster_ids << Id.new(arg)
+        end
+      end
+    end
+    alias << add
+    
+    def cluster_list
+      @cluster_ids.collect { |comm| comm.to_s }.join(' ')
+    end
+    
+    def to_s(method=:default)
+      super(cluster_list, method)
+    end
+
+    def to_ary
+      @cluster_ids.collect { |c| c.to_i }
+    end
+
+    def encode
+      super(@cluster_ids.collect { |comm| comm.encode }.join)
+    end
+
+    def parse(s)
+      @flags, @type, len, value=super(s)
+      self << value.unpack("N#{len/4}")
+    end
+
+    def sort
+      Cluster_list.new(to_ary.sort)
+    end
+
+    def sort!
+      @cluster_ids = @cluster_ids.sort_by { |c| c.to_i }
+      self
+    end
+
+    def <=>(other)
+      self.sort.to_shex <=> other.sort.to_shex
+    end
+
+  end
+
+end
+
+load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0