bgp4r 0.0.3

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

data/bgp/common.rb

@@ -0,0 +1,204 @@
+#    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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'ipaddr'
+require 'logger'
+
+class IPAddr
+  alias encode hton
+
+  def self.create(arg)
+    if arg.is_a?(String) and arg.is_packed?
+      IPAddr.new_ntoh(arg)
+    elsif arg.is_a?(Integer)
+      IPAddr.new_ntoh([arg].pack('N'))
+    elsif arg.is_a?(Array) and arg[0].is_a?(Fixnum)
+      IPAddr.new_ntoh([arg].pack('C*'))
+    else
+      IPAddr.new(arg)
+    end
+  end
+
+  #TODO: if not used, get rid of it.
+  def self.new_nlri4(arg)
+    if arg.is_a?(String) and arg.is_packed?
+      arg +=([0]*3).pack('C*')
+      plen, *nlri = arg.unpack('CC4')
+      ipaddr = nlri.collect { |n| n.to_s }.join('.') + "/" + plen .to_s
+      IPAddr.new(ipaddr)
+    else
+      IPAddr.new(arg)
+    end
+  end
+
+  def _mlen_
+    m = @mask_addr
+    len =  ipv6? ? 128 : 32
+    loop do
+      break if m & 1 > 0
+      m = m >> 1
+      len += -1
+    end
+    len
+  end
+  
+  def mlen
+    @_jme_mlen_ ||= _mlen_
+  end
+
+  def _generate_network_inc_
+    max_len =  ipv4? ? 32 : 128
+    Proc.new { |n| n*(2**(max_len - mlen)) }
+  end
+  def +(i)
+    [IPAddr.create(to_i + i).to_s, mlen].join("/")
+  end
+  def ^(i)
+    @increment ||= _generate_network_inc_
+    [IPAddr.create(to_i + @increment.call(i)).to_s, mlen].join("/")
+  end
+  private :_generate_network_inc_
+
+  def netmask
+    if ipv4?
+      [@mask_addr].pack('N').unpack('C4').collect { |x| x.to_s}.join('.')
+    else
+      #TODO netmask ipv6
+      @mask_addr
+    end
+  end
+
+end
+
+
+class Object
+  def to_shex(*args)
+    self.respond_to?(:encode) ? self.encode(*args).unpack('H*')[0] : ""
+  end
+  alias to_s_hexlify to_shex
+  def to_shex4(*args)
+    self.respond_to?(:encode4) ? self.encode4(*args).unpack('H*')[0] : ""
+  end
+  def to_shex_len(len, *args)
+    s = to_shex(*args)
+    "#{s[0..len]}#{s.size>len ? '...' : ''}"
+  end
+  def to_shex4_len(len, *args)
+    s = to_shex4(*args)
+    "#{s[0..len]}#{s.size>len ? '...' : ''}"
+  end
+end
+
+class Array
+  alias_method :old_pack, :pack
+  def pack(*args)
+    s = self.old_pack(*args)
+    s.instance_eval { @__is_packed__ = true }
+    s
+  end
+end
+
+class String
+  def is_packed?
+    defined?(@__is_packed__) and @__is_packed__
+  end
+  def is_packed
+     @__is_packed__ = true 
+     self
+  end
+  alias packed? :is_packed?
+  
+  def hexlify
+    return self unless is_packed?
+    s=self.dup
+    ls=[""]
+    n=0
+    while s.size>0
+      l = s.slice!(0,16)
+      ls << format("0x%4.4x: %s", n,
+          l.unpack("n#{l.size/2}").collect { |x| format("%4.4x",x) }.join(' '))
+      n+=1
+    end
+    ls
+  end
+  
+end
+
+class Log  < Logger
+  private_class_method :new 
+  @@logger = nil
+  def initialize(s)
+    super(s)
+    @@time=Time.now
+    self.datetime_format = "%M:%S"
+    self.level = Logger::INFO
+  end 
+  def Log.time_reset
+    @time = Time.now
+  end
+  def Log.create(s=STDERR)
+    @@logger ||= new(s)
+  end
+  def Log.set_filename(s)
+    @@logger = new(s)
+  end 
+  def Log.level=(level)
+    return unless (0..4) === level
+    @@logger.level=(level)
+  end 
+  def Log.level
+    case @@logger.level
+    when Logger::INFO ;  "(#{Logger::INFO }) 'INFO'"
+    when Logger::DEBUG ; "(#{Logger::DEBUG }) 'DEBUG'"
+    when Logger::WARN ;  "(#{Logger::WARN }) 'WARN'"
+    when Logger::ERROR ; "(#{Logger::ERROR }) 'ERROR'"
+    when Logger::FATAL ; "(#{Logger::FATAL }) 'FATAL'"
+    end
+  end
+  def Log.clear
+    `rm #{Log.filename}`
+    Log.set_filename(Log.filename)
+  end
+  def Log.filename
+    @@logger.instance_eval { @logdev.filename }
+  end
+  def Log.start(*arg)
+    Log.create(*arg)
+  end 
+  def Log.info(txt)
+    @@logger.info(txt) unless @@logger.nil?
+  end
+  def Log.fatal(txt)
+    @@logger.fatal(txt) unless @@logger.nil?
+  end
+  def Log.error(txt)
+    @@logger.error(txt) unless @@logger.nil?
+  end
+  def Log.debug(txt)
+    @@logger.debug(txt) unless @@logger.nil?
+  end
+  def Log.warn(txt)
+    @@logger.warn(txt) unless @@logger.nil?
+  end
+  def Log.<<(txt)
+    elapsed = Time.now - @@time
+    @@logger << "<< #{format "%4.6f", elapsed}: #{txt}\n" unless @@logger.nil?
+  end
+  def Log.>>(txt)
+    elapsed = Time.now.to_f - @@time.to_f
+    @@logger << ">> #{format "%4.6f", elapsed}: #{txt}\n" unless @@logger.nil?
+  end
+end 
+

data/bgp/communities.rb

@@ -0,0 +1,139 @@
+#--
+# 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 Communities < Attr
+
+    class Community
+      
+      def initialize(arg)
+        if arg.is_a?(Symbol)
+          case arg
+          when :no_export      ; @value=0xFFFFFF01
+          when :no_advertise   ; @value=0xFFFFFF02
+          when :no_export_sub_confed ; @value=0xFFFFFF03
+          when :no_peer        ; @value=0xFFFFFF04
+          else
+            raise ArgumentError, "invalid argument #{val}"
+          end
+        elsif arg.is_a?(String) and arg.split(':').size==2
+          self.value=arg.split(':').collect { |n| n.to_i }.pack('n2').unpack('N')[0]
+        else
+          self.value=arg
+        end
+      end
+
+      def value=(val)
+        raise ArgumentError, "invalid argument #{val}" unless val.is_a?(Fixnum) or val.is_a?(Bignum)
+        @value=val
+      end
+
+      def to_i
+        @value
+      end
+
+      def to_s
+        [@value >> 16, @value & 0xffff].join(':')
+      end
+
+      # The community attribute values ranging from 0x0000000 through
+      # 0x0000FFFF and 0xFFFF0000 through 0xFFFFFFFF are hereby reserved.
+      def is_reserved?
+        (0x0000000..0x0000FFFF ) === @value or (0xFFFF0000..0xFFFFFFFF) === @value
+      end
+
+      def encode
+        [@value].pack('N')
+      end
+
+    end
+
+    def initialize(*args)
+      @flags, @type = OPTIONAL_TRANSITIVE, COMMUNITIES
+      if args[0].is_a?(String) and args[0].is_packed?
+        parse(args[0])
+      elsif args[0].is_a?(self.class) and args[0].respond_to?(:encode)
+        parse(args[0].encode, *args[1..-1])
+      else
+        add(*args)
+      end
+    end
+
+    def add(*args)
+      @communities ||=[]
+      args.flatten.each do |arg|
+        if arg.is_a?(String) and arg.split(' ').size>1
+          arg.split.each { |v| @communities << Community.new(v) }
+        elsif arg.is_a?(String) and arg.split(',').size>1
+          arg.split(',').each { |v| @communities << Community.new(v) }
+        elsif arg.is_a?(Community)
+          @communities << arg
+        else
+          @communities << Community.new(arg)
+        end
+      end
+    end
+    alias << add
+
+    def communities
+      @communities.collect { |comm| comm.to_s }.join(' ')
+    end
+
+    def to_s(method=:default)
+      super(communities, method)
+    end
+
+    def to_ary
+      @communities.collect { |c| c.to_i }
+    end
+
+    def encode
+      super(@communities.collect { |comm| comm.encode }.join)
+    end
+
+    def parse(s)
+      @flags, @type, len, value=super(s)
+      self << value.unpack("N#{len/4}")
+    end
+
+    def sort
+      Communities.new(to_ary.sort)
+    end
+
+    def sort!
+      @communities = @communities.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