bgp4r 0.0.3

data/bgp/mp_reach.rb

@@ -0,0 +1,208 @@
+#--
+# 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'
+require 'bgp/nlri'
+
+module BGP
+
+    class Mp_unreach < Attr
+
+      attr_reader :safi, :nlris
+
+      def initialize(*args)
+        @safi, @nlris= 1, []
+        @flags, @type = OPTIONAL, MP_UNREACH
+        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])
+        elsif args[0].is_a?(Hash) and args.size==1
+          set(*args)
+        else
+          raise ArgumentError, "invalid argument" 
+        end
+      end
+
+      def afi
+        @afi ||= @nlris[0].afi
+      end
+
+      def set(h)
+        @safi = h[:safi]
+        case @safi
+        when 1,2
+          @nlris = [h[:prefix]].flatten.collect { |p| p.is_a?(Prefix) ? p : Prefix.new(p) }
+        when 4
+          @nlris = [h[:nlri]].flatten.collect { |n|
+            prefix = n[:prefix].is_a?(String) ? Prefix.new(n[:prefix]) : n[:prefix]
+            Labeled.new(prefix, *n[:label]) 
+          }
+        when 128,129 ; @nlris = [h[:nlri]].flatten.collect { |n| 
+          prefix = n[:prefix].is_a?(Prefix) ? n[:prefix] :  Prefix.new(n[:prefix]) 
+          rd = n[:rd].is_a?(Rd) ?  n[:rd] : Rd.new(*n[:rd])
+          Labeled.new(Vpn.new(prefix,rd), *n[:label]) }
+        else
+        end
+      end
+
+      def mp_unreach
+        "\n    AFI #{IANA.afi(afi)} (#{afi}), SAFI #{IANA.safi(safi)} (#{safi})" +
+        (['']+ @nlris.collect { |nlri| nlri.to_s }).join("\n      ")
+      end
+
+      def to_s(method=:default)
+        super(mp_unreach, method)
+      end
+
+      def parse(s)
+        @flags, @type, len, value = super(s)
+        @afi, @safi = value.slice!(0,3).unpack('nC')
+        while value.size>0
+          blen = value.slice(0,1).unpack('C')[0]
+          @nlris << Nlri.factory(value.slice!(0,(blen+7)/8+1), @afi, @safi)
+        end
+        raise RuntimeError, "leftover afer parsing: #{value.unpack('H*')}" if value.size>0
+      end
+
+      def encode
+        super([afi, @safi, @nlris.collect { |n| n.encode }.join].pack('nCa*'))
+      end
+      
+    end
+    
+    class Mp_reach < Attr
+      
+      attr_reader :safi, :nlris
+      
+      def initialize(*args)
+        @safi, @nexthops, @nlris= 1, [], [] # default is ipv4/unicast
+        @flags, @type = OPTIONAL, MP_REACH
+        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])
+        elsif args[0].is_a?(Hash) and args.size==1
+          set(*args)
+        else
+          raise ArgumentError, "invalid argument" 
+        end
+      end
+      
+      def afi
+        @afi ||= @nexthops[0].afi
+      end
+      
+      def set(h)
+        @safi = h[:safi]
+        case @safi
+        when 1,2,4   ; @nexthops = [h[:nexthop]].flatten.collect { |nh| Prefix.new(nh) }
+        when 128,129 ; @nexthops = [h[:nexthop]].flatten.collect { |nh| Vpn.new(nh) }
+        else
+        end
+        case @safi
+        when 1,2
+          @nlris = [h[:prefix]].flatten.collect { |n| Prefix.new(n) }
+        when 4
+          @nlris = [h[:nlri]].flatten.collect { |n|
+            prefix = n[:prefix].is_a?(String) ? Prefix.new(n[:prefix]) : n[:prefix]
+            Labeled.new(prefix, *n[:label]) 
+          }
+        when 128,129 ; @nlris = [h[:nlri]].flatten.collect { |n| 
+          prefix = n[:prefix].is_a?(Prefix) ? n[:prefix] :  Prefix.new(n[:prefix]) 
+          rd = n[:rd].is_a?(Rd) ?  n[:rd] : Rd.new(*n[:rd])
+          Labeled.new(Vpn.new(prefix,rd), *n[:label]) }
+        else
+        end
+      end
+      
+      def nexthops
+        @nexthops.collect { |nh| nh.nexthop }.join(", ")
+      end
+      
+      def mp_reach
+        "\n    AFI #{IANA.afi(afi)} (#{afi}), SAFI #{IANA.safi(safi)} (#{safi})" +
+        "\n    nexthop: " + nexthops +
+        (['']+ @nlris.collect { |nlri| nlri.to_s }).join("\n      ")
+      end
+      
+      def to_s(method=:default)
+        super(mp_reach, method)
+      end
+      
+      def to_hash
+      end
+      
+      
+      def parse(s)
+        @flags, @type, len, value = super(s)
+        @afi, @safi, nh_len = value.slice!(0,4).unpack('nCC')
+        parse_next_hops value.slice!(0,nh_len).is_packed
+        value.slice!(0,1)
+        while value.size>0
+          blen = value.slice(0,1).unpack('C')[0]
+          @nlris << Nlri.factory(value.slice!(0,(blen+7)/8+1), @afi, @safi)
+        end
+        raise RuntimeError, "leftover afer parsing: #{value.unpack('H*')}" if value.size>0
+        
+      end
+      
+      def parse_next_hops(s)
+        while s.size>0
+          case @safi
+          when 1,2,4
+            case @afi
+            when 1
+              @nexthops << Prefix.new([32,s.slice!(0,4)].pack('Ca*'),1)
+            when 2
+              @nexthops << Prefix.new([128,s.slice!(0,16)].pack('Ca*'),2)
+            end
+          when 128,129
+            @nexthops << Vpn.new([64+32,s.slice!(0,12)].pack('Ca*'))
+          else
+            raise RuntimeError, "cannot parse nexthop for safi #{@safi}"
+          end
+        end
+      end
+      
+      def encode(what=:mp_reach)
+        case what
+        when :mp_reach
+          nexthops = @nexthops.collect { |nh| nh.encode(false) }.join
+          super([afi, @safi, nexthops.size, nexthops, 0, @nlris.collect { |n| n.encode }.join].pack('nCCa*Ca*'))
+        when :mp_unreach
+          super([afi, @safi, @nlris.collect { |n| n.encode }.join].pack('nCa*'))
+        end
+      end
+      
+      def new_unreach
+        s = encode(:mp_unreach)
+        s[1]= [MP_UNREACH].pack('C')
+        Mp_unreach.new(s)
+      end
+      
+    end
+      
+end
+
+load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/multi_exit_disc.rb

@@ -0,0 +1,76 @@
+#--
+# 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 Multi_exit_disc < Attr
+
+    def initialize(arg=0)
+      @flags, @type=OPTIONAL, MULTI_EXIT_DISC
+      if arg.is_a?(String) and arg.is_packed?
+        parse(arg)
+      elsif arg.is_a?(self.class)
+        parse(arg.encode)
+      elsif arg.is_a?(Integer)
+        @med = arg
+      elsif arg.is_a?(Hash) and arg[:multi_exit_disc] or arg[:med]
+        self.med = arg[:med] if arg[:med]
+        self.med = arg[:multi_exit_disc] if arg[:multi_exit_disc]
+      else
+        raise ArgumentError, "invalid argument, #{arg.inspect}"
+      end
+    end
+
+    def med=(val)
+      raise ArgumentError, "invalid argument" unless val.is_a?(Integer)
+      @med=val
+    end
+
+    def to_i
+      @med
+    end
+
+    def encode
+      super([to_i].pack('N'))
+    end
+    
+    def multi_exit_disc
+      format("(0x%4.4x) %d", to_i, to_i)
+    end
+
+    def to_s(method=:default)
+      super(multi_exit_disc, method)
+    end
+
+    private
+
+    def parse(s)
+      @flags, @type, len, @med=super(s,'N')
+    end
+
+  end
+
+end
+load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/neighbor.rb

@@ -0,0 +1,291 @@
+#--
+# 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 'socket'
+require 'thread'
+require 'observer'
+
+module BGP
+
+  class Neighbor
+    include Observable
+
+    def initialize(*args)
+      @opt_parms = []
+      if args.size==1 and args[0].is_a?(Hash)
+        @version = args[0][:version] if args[0][:version]
+        @my_as = args[0][:my_as] if args[0][:my_as]
+        @holdtime = args[0][:holdtime] if args[0][:holdtime]
+        @id = args[0][:id] if args[0][:id]
+        @remote_addr = args[0][:remote_addr] if args[0][:remote_addr]
+        @local_addr = args[0][:local_addr] if args[0][:local_addr]
+      else
+        @version, @my_as, @holdtime, @id, @remote_addr, @local_addr  = args
+      end
+      @as4byte=false
+      @state = :Idle
+      @threads=ThreadGroup.new
+      @mutex = Mutex.new
+      @eventQ = Queue.new
+      event_dispatch
+    end
+    
+    #  neighbor.capability :as4_byte
+    #  neighbor.capability :route_refresh
+    #  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 ; Route_refresh_cap.new(*args[1..-1])
+        when :mbgp          ; Mbgp_cap.new(*args[1..-1])
+        when :as4_byte      ; As4_cap.new(@my_as)
+        end        
+      elsif args[0].is_a?(Capability) and args.size==1
+        args[0]
+      else
+        raise ArgumentError, "Invalid argument"
+      end
+    end
+
+    def state
+      @state.to_s
+    end
+
+    def retry_thread(action=:start)
+      case action
+      when :start
+        @restart_thread = Thread.new do
+          Thread.current['name']='restart'
+          loop do
+            enable if @state == :Idle
+            sleep(5)
+          end
+        end
+
+      when :stop
+        if defined? @restart_thread and @restart_thread.alive?
+          @restart_thread.kill ; @restart_thread.join
+        end
+      end
+    end
+
+    def event_dispatch
+      Thread.new(@eventQ) do |eventQ|
+        loop do
+          ev, type, m = eventQ.deq
+          case ev
+          when :ev_msg
+            msg = BGP::Message.factory(m)
+            Log.info "Recv#{msg.class.to_s.split('::')[-1]}"
+            Log.debug "Recv #{msg}\n"            
+            changed and notify_observers(msg)
+            if msg.is_a?(Update)
+              rcv_update(msg)
+            elsif msg.is_a?(Notification)
+              rcv_notification(msg)
+            elsif msg.is_a?(Open)
+              rcv_open(msg)
+            elsif msg.is_a?(Route_refresh)
+              rcv_route_refresh(msg)
+            elsif msg.is_a?(Orf_route_refresh)
+              rcv_route_refresh(msg)
+            elsif msg.is_a?(Keepalive)
+              rcv_keepalive
+            else
+              Log.error "unexpected message type #{type}"
+            end
+          when :ev_conn_reset
+            Log.warn "#{type}"
+            disable
+          when :ev_holdtime_expire
+            Log.warn "Holdtime expire: #{type}"
+            disable
+          else
+            Log.error "unexpected event #{ev}"
+          end
+        end
+      end
+    end
+
+    def clean
+      @threads.list.each { |x| 
+        x.exit; x.join
+        Log.info "#{x['name']}: stopped at #{Time.now.strftime("%I:%M:%S%P")}"
+      }
+    end
+
+
+    def _open_msg_
+      @open = BGP::Open.new(@version, @my_as, @holdtime, @id, *@opt_parms)
+    end
+    private :_open_msg_
+
+    def enable(auto_retry=:no_auto_retry, wait= :wait)
+      return if @state == :Established
+      disable unless @state == :Idle
+      
+      init_socket
+      init_io
+      @open = _open_msg_
+            
+      [@in, @out].each { |io| 
+        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
+      
+      if wait == :wait
+        loop do
+          sleep(0.3)
+          break if @state == :Established
+        end
+        Log.info "#{self} started"
+      end
+      
+    rescue => e
+      Log.error "#{e}"
+      disable
+    end
+    alias start enable
+        
+    def disable
+      @socket.close  if defined?(@socket) and not @socket.closed?
+      clean
+      new_state :Idle, "Disable"
+    end
+    alias stop disable
+
+    def send_message(m)
+      return unless @out
+      unless m.is_a?(String)
+        Log.info "Send#{m.class.to_s.split('::')[-1]}"
+        Log.debug "Send #{m.is_a?(Update) ? m.to_s(@as4byte) : m }\n"
+      end
+      if m.is_a?(Update)
+        @out.enq m.encode(@as4byte)
+      else
+        @out.enq m
+      end
+    end
+
+    def init_socket
+      @socket = Socket.new(Socket::PF_INET, Socket::SOCK_STREAM, Socket::IPPROTO_TCP)
+      remote = Socket.pack_sockaddr_in(179, @remote_addr) 
+      local = Socket.pack_sockaddr_in(0, @local_addr) unless @local_addr.nil?
+      remote_sock_addr = Socket.pack_sockaddr_in(179, @remote_addr) 
+      local_sock_addr = Socket.pack_sockaddr_in(0, @local_addr) unless @local_addr.nil? 
+      @socket.bind(local_sock_addr) unless @local_addr.nil?
+      @socket.connect(remote_sock_addr)
+    end
+      
+    def init_io
+      @in = BGP::IO::Input.new(@socket, @holdtime, self)
+      @out = BGP::IO::Output.new(@socket, @holdtime, self)
+      new_state(:Active, "Open Socket")
+    end
+        
+    def update(*args)
+      @eventQ.enq(args)
+    end
+    
+    def new_state(state, txt='')
+      Log.info "#{txt} old state #{@state} new state #{state}"
+      @state = state
+    end
+
+    def _send_open_(open)
+      send_message open
+    end
+    private :_send_open_
+
+    def send_open(ev)
+      case @state
+      when :OpenRecv
+        _send_open_ @open ; new_state :OpenConfirm, ev
+      when :Active
+        _send_open_ @open     ; new_state :OpenSent, ev
+      else
+        Log.warn "#{self.class}: attempt to send OPEN msg while in #{@state}"
+      end    
+    end
+  
+    def rcv_open(o)
+      @rmt_version = o.version
+      @rmt_as = o.local_as
+      @rmt_bgp_id = o.bgp_id
+
+      if @holdtime > o.holdtime
+        @out.holdtime = @in.holdtime = o.holdtime
+      end
+
+      case @state
+      when :OpenSent
+        send_message(BGP::Message.keepalive)
+        new_state :OpenConfirm, "RecvOpen"
+      when :Active
+        send_open "RecvOpen"
+        new_state :OpenConfirm, "RecvOpen"
+      else
+        Log.warn "#{self.class}: received open message while in state #{@state}"
+      end
+      
+      @as4byte = (@open.has?(As4_cap) and o.has?(As4_cap))
+    end
+    
+    def rcv_keepalive
+      if @state == :OpenConfirm
+        send_message(BGP::Keepalive.new)
+        Log.debug "SendKeepAlive"
+        new_state(:Established, 'RecvKeepAlive')
+        @keepalive_thread = Thread.new(@holdtime/3) do |h|
+          Thread.current['name'] = "BGP Keepalive interval:(#{h})"
+          loop do
+            sleep(h)
+            send_message(BGP::Keepalive.new)
+          end
+        end
+        @threads.add(@keepalive_thread)
+      end
+    end
+
+    def rcv_notification(m)
+      Log.info "#{m}"
+      disable
+    end
+    
+    def to_s
+      "version: #{@version}, id: #{@id}, as: #{@my_as}, holdtime: #{@holdtime}, peer addr: #{@remote_addr}, local addr: #{@local_addr}"
+    end
+
+  end
+
+end
+
+load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0

data/bgp/next_hop.rb

@@ -0,0 +1,63 @@
+#--
+# 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 Next_hop < Attr
+
+    def initialize(*args)
+      @flags, @type = WELL_KNOWN_MANDATORY, NEXT_HOP
+      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
+        @next_hop = IPAddr.create(*args)
+      end
+    end
+
+    def next_hop
+      @next_hop.to_s
+    end
+    def to_s(method=:default)
+      super(next_hop, method)
+    end
+
+    def to_i
+      @next_hop.to_i
+    end
+    def parse(s)
+      @flags, @type, len, value = super(s)
+      @next_hop = IPAddr.new_ntoh(value[0,4])
+    end
+
+    def encode
+      super(@next_hop.encode)
+    end
+
+  end
+
+end
+load "../test/#{ File.basename($0.gsub(/.rb/,'_test.rb'))}" if __FILE__ == $0