bgp4r 0.0.13 → 0.0.14

data/test/unit/path_attributes/mp_reach_test.rb

@@ -410,7 +410,6 @@ class Mp_reach_Test < Test::Unit::TestCase
     assert_match(/ID=100, 49.0a10.0b00.0000.0000.0000.0000.0000.0000.0000.00\/32/, mpr.to_s)
     assert_match(/ID=101, 49.0a20.0b00.0000.0000.0000.0000.0000.0000.0000.00\/32/, mpr.to_s)
     assert_match(/ID=102, 49.0a30.0b00.0000.0000.0000.0000.0000.0000.0000.00\/32/, mpr.to_s)
-
     
   end
   
@@ -436,8 +435,7 @@ class Mp_reach_Test < Test::Unit::TestCase
     
     assert_equal('800e10000104040a0000010030000651c0a800', mpr1.to_shex)
     assert_equal('800e14000104040a000001000000006430000651c0a800', mpr2.to_shex)
-    
-    
+  
     assert_equal attr_len(mpr1)+4, attr_len(mpr2)
     
     assert_equal('800e1e000104040a0000010030000651c0a80030000661c0a80130000671c0a801', mpr3.to_shex)
@@ -474,6 +472,7 @@ class Mp_reach_Test < Test::Unit::TestCase
       {:rd=> [100,100], :prefix=> '192.168.1.0/24', :label=>102},
       {:rd=> [100,100], :prefix=> '192.168.2.0/24', :label=>103},
     ]
+    
     mpr4 = Mp_reach.new :safi=>128, :nexthop=> ['10.0.0.1'], :path_id=> 100, :nlris=> [
       {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101},
       {:rd=> [100,100], :prefix=> '192.168.1.0/24', :label=>102},
@@ -527,7 +526,9 @@ class Mp_reach_Test < Test::Unit::TestCase
     assert_match(/^\s+Label Stack=101 /, mpr.to_s)
     assert_match(/^\s+Label Stack=102 /, mpr.to_s)
     assert_match(/^\s+Label Stack=103 /, mpr.to_s)
-
+    
+    assert_equal(s.split.join, mpr.to_shex)
+    
     s = '80 0e 4a 0001 80 0c 00000000000000000a000001 00 00000065 70 000651 0000006400000064 c0a800
                                                          00000066 70 000661 0000006400000064 c0a801
                                                          00000067 70 000671 0000006400000064 c0a802'
@@ -537,6 +538,14 @@ class Mp_reach_Test < Test::Unit::TestCase
     assert_match(/Label Stack=102.*ID=102, /, mpr.to_s)
     assert_match(/Label Stack=103.*ID=103, /, mpr.to_s)
     
+    s = '80 0e 3b 0001 80 0c 0000000000000000 0a000001 00 70 000651 0000006400000064 c0a800
+                                                          70 000661 0000006400000064 c0a801
+                                                          58 000671 0000006400000064'
+    sbin = [s.split.join].pack('H*')
+    mpr = Mp_reach.new(sbin, false)
+    assert_equal(s.split.join, mpr.to_shex)
+    assert_match(/IPv4=0.0.0.0\/0/, mpr.to_s)
+  
   end
   
   def test_derive_afi_from_nlris
@@ -554,6 +563,44 @@ class Mp_reach_Test < Test::Unit::TestCase
       ]))
   end
   
+  def test_to_hash
+    
+    mpr1 = Mp_reach.new :safi=>128, :nexthop=> ['10.0.0.1'], 
+                        :nlris=> {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101}
+    mpr2 = Mp_reach.new :safi=>128, :nexthop=> ['10.0.0.1'], 
+                        :nlris=> {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101, :path_id=>100}
+    mpr3 = Mp_reach.new :safi=>128, :nexthop=> ['10.0.0.1'], :nlris=> [
+      {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101},
+      {:rd=> [100,100], :prefix=> '192.168.1.0/24', :label=>102},
+      {:rd=> [100,100], :prefix=> '192.168.2.0/24', :label=>103},
+    ]
+    
+    h = {:safi=>128, :nexthop=> ['10.0.0.1'], 
+                        :nlris=> {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101}}
+
+    assert_equal( 128, mpr1.to_hash[:mp_reach][:safi])
+    assert_equal( 1, mpr1.to_hash[:mp_reach][:afi])
+    assert_equal( h[:nexthop], mpr1.to_hash[:mp_reach][:nexthop])
+    assert_equal( h[:nlris], mpr1.to_hash[:mp_reach][:nlris])
+    
+    h = {:safi=>128, :nexthop=> ['10.0.0.1'], :nlris=> [
+      {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101},
+      {:rd=> [100,100], :prefix=> '192.168.1.0/24', :label=>102},
+      {:rd=> [100,100], :prefix=> '192.168.2.0/24', :label=>103},
+      ]}
+
+    assert_equal( 128, mpr3.to_hash[:mp_reach][:safi])
+    assert_equal( 1, mpr3.to_hash[:mp_reach][:afi])
+    assert_equal( h[:nexthop], mpr3.to_hash[:mp_reach][:nexthop])
+    assert_equal( h[:nlris], mpr3.to_hash[:mp_reach][:nlris])
+    
+    
+    assert_equal(mpr1.to_hash, Mp_reach.new(mpr1.to_hash[:mp_reach]).to_hash)
+    assert_equal(mpr2.to_hash, Mp_reach.new(mpr2.to_hash[:mp_reach]).to_hash)
+    assert_equal(mpr3.to_hash, Mp_reach.new(mpr3.to_hash[:mp_reach]).to_hash)
+    
+  end
+    
   private
   
   def attr_len(attr)

data/test/unit/path_attributes/mp_unreach_test.rb

@@ -87,14 +87,16 @@ class Mp_unreach_Test < Test::Unit::TestCase
       {:prefix=> '192.168.2.0/24', :path_id=> 102},
     ])
     
+    h = {:safi=>1, :nlris=> '192.168.1.0/24', :afi=>1}
+    assert_equal(h, mpr1.to_hash[:mp_unreach])
     
-    # 
-    # puts mpr1
-    # puts mpr2
-    # puts mpr3
-    # puts mpr4
-    # puts mpr5
-    # 
+    assert_equal({:safi=>1, :nlris=>{:prefix=>"192.168.1.0/24", :path_id=>100}, :afi=>1}, mpr2.to_hash[:mp_unreach])
+
+    assert_equal(mpr1.to_hash, Mp_unreach.new(mpr1.to_hash[:mp_unreach]).to_hash)
+    assert_equal(mpr2.to_hash, Mp_unreach.new(mpr2.to_hash[:mp_unreach]).to_hash)
+    assert_equal(mpr3.to_hash, Mp_unreach.new(mpr3.to_hash[:mp_unreach]).to_hash)
+    assert_equal(mpr4.to_hash, Mp_unreach.new(mpr4.to_hash[:mp_unreach]).to_hash)
+    assert_equal(mpr5.to_hash, Mp_unreach.new(mpr5.to_hash[:mp_unreach]).to_hash)
     assert_equal('800f0700010118c0a801', mpr1.to_shex)
     assert_equal('800f0b0001010000006418c0a801', mpr2.to_shex)
     assert_equal attr_len(mpr1)+4, attr_len(mpr2)

data/test/unit/path_attributes/next_hop_test.rb

@@ -34,4 +34,7 @@ class Next_hop_Test < Test::Unit::TestCase
     next_hop1 = Next_hop.new(next_hop)
     assert_equal(next_hop.encode, next_hop1.encode)
   end
+  def test_2
+    next_hop = Next_hop.new :next_hop=> '10.0.0.1'
+  end
 end

data/test/unit/path_attributes/origin_test.rb

@@ -54,5 +54,6 @@ class Origin_Test < Test::Unit::TestCase
     assert_equal("[wTcr]  (1)     Origin: [40010100] 'igp'", Origin.new.to_s)
     assert_equal("[wTcr]  (1)     Origin: [40010100] 'igp'", Origin.new(:igp).to_s)
     assert_equal("Origin (1), length: 1, Flags [T]: igp\n   0x0000:  00", Origin.new.to_s(:tcpdump))
+    assert_equal({:origin=>:egp}, Origin.new(:egp).to_hash)
   end
 end

data/test/unit/path_attributes/path_attribute_test.rb

@@ -48,8 +48,16 @@ class Path_attribute_Test < Test::Unit::TestCase # :nodoc:
       BGP::Communities], @pa.has?)
     assert(@pa.has? Multi_exit_disc)
     assert(@pa.has? As_path)
+    pa = Path_attribute.new { |p|  
+      p << Origin.new(1)
+      p << Next_hop.new('1.1.1.1')
+      p << Multi_exit_disc.new(222)
+      p << Local_pref.new(333)
+      p << As_path.new( :set=> [1,2,3,4], :sequence=> [11,12,13])
+    }
+    assert_equal([BGP::Origin,BGP::Next_hop,BGP::Multi_exit_disc,BGP::Local_pref,BGP::As_path], pa.has?)
   end
-
+  
   def test_2
     ss = '400101014003040a000001800404000000644005040000006440020c020500010002000300040005c0080c051f00010137003b0af50040'
     assert_equal(ss, @pa.to_shex)
@@ -153,6 +161,49 @@ class Path_attribute_Test < Test::Unit::TestCase # :nodoc:
     assert_equal(BGP::Mp_reach, Attr.factory(sbin, :path_id=>true).class)
   end
   
+  def test_8
+    
+    mp_reach = {:safi=>128, :nexthop=> ['10.0.0.1'], :path_id=> 100, :nlris=> [
+      {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101},
+      {:rd=> [100,100], :prefix=> '192.168.1.0/24', :label=>102},
+      {:rd=> [100,100], :prefix=> '192.168.2.0/24', :label=>103},
+    ]}
+    
+    mp_unreach = {:safi=>2, :nlris=>['192.168.1.0/24', '192.168.2.0/24']}
+    
+    p = Path_attribute.new  :local_pref=>100, 
+                            :next_hop => '10.0.0.1', 
+                            :med=>300, 
+                            :mp_reach=> mp_reach, 
+                            :mp_unreach=> mp_unreach, 
+                            :origin=> :igp, 
+                            :as_path=> {:set=> [1,2], :sequence=>[3,4], :confed_sequence=>[5,6], :confed_set=>[7,8]},
+                            :cluster_list=> ['1.1.1.1', '2.2.2.2', '3.3.3.3'],
+                            :communities=> ["145:30", "145:40", "145:50", "145:60", :no_export, :no_advertise,],
+                            :extended_communities=> { :color => 100, :link_bandwidth => 999_999_999, :route_origin => ['10.0.1.2', 10], :encapsulation => :ipip },
+                            :aggregator=> { :address=>'1.1.1.1', :asn=>100 },
+                            :originator_id=> '2.2.2.2',
+                            :as4_aggregator=> { :asn=> 200, :address=> '4.4.4.4' },
+                            :as4_path=> {:set=> [11,12], :sequence=>[13,14], :confed_sequence=>[15,16], :confed_set=>[17,18]},
+                            :atomic_aggregate=> 1
+  
+    assert p.has?(Origin), "Path attributes should have a Origin attr."
+    assert p.has?(Local_pref), "Path attributes should have a Local_pref attr."
+    assert p.has?(Next_hop), "Path attributes should have a Next_hop  attr."
+    assert p.has?(Multi_exit_disc), "Path attributes should have a Multi_exit_disc attr."
+    assert p.has?(As_path), "Path attributes should have a As_path attr."
+    assert p.has?(As4_path), "Path attributes should have a As4_path attr."
+    assert p.has?(As4_aggregator), "Path attributes should have a As4_aggregator attr."
+    assert p.has?(Mp_reach), "Path attributes should have a Mp_reach attr."
+    assert p.has?(Mp_unreach), "Path attributes should have a Mp_unreach attr."
+    assert p.has?(Communities), "Path attributes should have a Communities attr."
+    assert p.has?(Extended_communities), "Path attributes should have a Extended_communities attr."
+    assert p.has?(Atomic_aggregate), "Path attributes should have a Atomic_aggregate attr."
+    assert p.has?(Originator_id), "Path attributes should have a Originator_id attr."
+    assert p.has?(Cluster_list), "Path attributes should have a Cluster_list attr."
+    
+  end
+  
   def test_path_attribute_path_id_true_and_as4byte_false
     path_attr = Path_attribute.new
     path_attr.insert(
@@ -172,6 +223,6 @@ class Path_attribute_Test < Test::Unit::TestCase # :nodoc:
     # TODO: UT: a path attr with mp_unreach w path_id
     # TODO: UT: a path attr with mp_reach w path_id and as4
     
-  end
+  end      
   
 end

data/test/unit/path_attributes/tlvs/tlv_test.rb

@@ -0,0 +1,33 @@
+require "test/unit"
+
+require "bgp/path_attributes/tlvs/tlv"
+require 'bgp/path_attributes/attribute'
+
+module BGP
+  class MyAttr < Attr
+    include TLV
+    include STLV
+    def initialize(value)
+      @flags, @type = OPTIONAL_NON_TRANSITIVE, 55
+      @value = value
+      @tlv_type=1
+      @stlv_type=2
+    end
+    def encode
+      super(@value)
+    end
+  end
+end
+
+class TestBgpPathAttributesTlvsTlv < Test::Unit::TestCase
+  include BGP
+  def test_1
+    attr = MyAttr.new([0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef].pack('N*'))
+    assert_equal('803716 0001 0012 02 10 deadbeef deadbeef deadbeef deadbeef'.split.join, attr.to_shex)
+    assert_equal(2, attr.stlv_type)
+    assert_equal(1, attr.tlv_type)
+  end
+end
+
+
+

data/test/unit/path_attributes/tunnel_encapsulation_test (Jean-Michel's Laptop's conflicted copy 2011-11-02).rb

@@ -0,0 +1,388 @@
+require "test/unit"
+require "bgp/path_attributes/tunnel_encapsulation"
+require 'bgp4r'
+require 'test/helpers/server'
+
+
+class TestTunnelEncapsulation < Test::Unit::TestCase
+  include BGP
+  
+  class TestColor < Test::Unit::TestCase
+    include BGP
+    def test_case_name
+      color = Tunnel_encapsulation::Color.new(10)
+      assert_equal('0408030b00000000000a',color.to_shex)
+      assert_equal(4, color.stlv_type)
+    end
+  end
+
+  class TestProtocolTYpe < Test::Unit::TestCase
+    include BGP
+    def test_case_name
+      protocol_type = Tunnel_encapsulation::Protocol_type.new :ipv4
+      assert_equal('02020800', protocol_type.to_shex)
+      assert_equal(2, protocol_type.stlv_type)
+      assert_equal('020286dd', Tunnel_encapsulation::Protocol_type.new(:ipv6).to_shex)
+      assert_equal('02028847', Tunnel_encapsulation::Protocol_type.new(:mpls).to_shex)
+    end
+  end
+  
+  class TestEncapsulationGre < Test::Unit::TestCase
+    include BGP
+    def test_case_name
+      encap = Tunnel_encapsulation::Encap_gre.new(0x12345678)
+      assert_equal('010412345678', encap.to_shex)
+    end
+  end
+
+  class TestEncapsulationL2tpv3 < Test::Unit::TestCase
+    include BGP
+    def test_case_name
+      encap = Tunnel_encapsulation::Encap_l2tpv3.new(0x1234, '1234567890123456789')
+      assert_equal('010e0000123412345678901234567890', encap.to_shex)
+    end
+  end
+
+  class TestTunnel < Test::Unit::TestCase
+    include BGP
+    def test_case_name
+      tlv = Tunnel_encapsulation::Tunnel.new(:tunnel_type=> :l2tpv3, :session_id=> 1, :cookie=> 'ffddeeaabb11ee3344', :proto_type=> :ipv4, :color=> 1234)
+      assert_equal('0001001d010d00000001ffddeeaabb11ee3344020208000408030b0000000004d2', tlv.to_shex)
+    end
+  end
+
+  
+  def test_case_name
+    tunnel_encap = Tunnel_encapsulation.new
+    assert_equal('c01700', tunnel_encap.to_shex)
+    tunnel_encap.add :tunnel_type=> :l2tpv3, :session_id=> 1, :coockie=> 0x1234, :proto_type=> :ipv4, :color=> 1234
+    assert_equal('c01718 0001 0014 01 04 00000001 02 02 0800 04 08 030b0000000004d2'.split.join, tunnel_encap.to_shex)
+    tunnel_encap.add :tunnel_type=> :l2tpv3, :session_id=> 2, :coockie=> 0x1234, :proto_type=> :ipv6, :color=> 1234
+    assert_equal('c0173000010014010400000001020208000408030b0000000004d200010014010400000002020286dd0408030b0000000004d2'.split.join, tunnel_encap.to_shex)
+    tunnel_encap.add :tunnel_type=> :l2tpv3, :session_id=> 3, :coockie=> 0x1234, :proto_type=> :mpls, :color=> 1234
+    assert_equal('c0174800010014010400000001020208000408030b0000000004d200010014010400000002020286dd0408030b0000000004d200010014010400000003020288470408030b0000000004d2'.split.join, tunnel_encap.to_shex)
+    tunnel_encap.add :tunnel_type=> :gre, :key=> 0x12345678
+    assert_equal('c0175200010014010400000001020208000408030b0000000004d200010014010400000002020286dd0408030b0000000004d200010014010400000003020288470408030b0000000004d200020006010412345678', tunnel_encap.to_shex)
+  end
+  include BGP::TestHelpers
+  
+  # def teardown
+  #   stop_server
+  # end
+  
+  # def test_send_update_with_tunnel_encap_attribute
+  # 
+  #   start_server(179)
+  #   
+  #   @c = Neighbor.new(4, 100, 180, '0.0.0.2', '127.0.0.1', '127.0.0.1')
+  #   @c.start :port=> 179
+  #   assert_equal('Established', @c.state)
+  #   assert_equal('Established', @s.state)
+  # 
+  #   tunnel_encap = Tunnel_encapsulation.new
+  #   tunnel_encap.add :tunnel_type=> :l2tpv3, :session_id=> 1, :coockie=> 0x1234, :proto_type=> :ipv4, :color=> 1234
+  #   tunnel_encap.add :tunnel_type=> :l2tpv3, :session_id=> 2, :coockie=> 0x1234, :proto_type=> :ipv6, :color=> 1234
+  #   tunnel_encap.add :tunnel_type=> :l2tpv3, :session_id=> 3, :coockie=> 0x1234, :proto_type=> :mpls, :color=> 1234
+  #   tunnel_encap.add :tunnel_type=> :gre, :key=> 0x12345678
+  #   
+  #   u = Update.new
+  #   u << tunnel_encap
+  #   
+  #   @c.send_message u
+  #   @c.send_message u
+  #   @c.send_message u
+  #   @c.send_message u
+  #   @c.send_message u
+  #   sleep 2
+  #       
+  # end
+  
+  
+  
+end
+
+
+__END__
+
+tunnels=[]
+
+
+
+
+Tunnel Type
+L2TPV3 =1
+GRE = 2
+IPIP = 7
+
+
+tunnel_encap attr:
+
+  tlv type 1: 
+    value: 
+      stlv-type 1 : session_id + coockie
+      stlv-proto-type 2 : ipv4  0x0800
+      stlv-color 4 : 0x1234
+    
+  
+  tlv type 1:
+    value:
+      stlv-type 1: session_id + coockie
+      stlv-proto-type 2 : ipv6 0x86dd
+      stlv-color 4 : 0x1234
+  
+  tlv type 1:
+    value:
+      stlv-type 1: session_id + coockie
+      stlv-proto-type 2 : mpls  0x8847
+      stlv-color 4 : 0x1234
+      
+   
+
+  tlv type 2:  (gre)
+    value: 
+      stlv-type 1: gre key (4)
+
+
+
+
+  
+
+  sub-tlv: session_id + coockie
+
+
+For example, if we want to use three L2TPv3 sessions, one carrying
+IPv4 packets, one carrying IPv6 packets, and one carrying MPLS
+packets, the egress router will include three TLVs of L2TPv3
+encapsulation type, each specifying a different Session ID and a
+different payload type.  The protocol type sub-TLV for these will be
+IPv4 (protocol type = 0x0800), IPv6 (protocol type = 0x86dd), and
+MPLS (protocol type = 0x8847), respectively.  This informs the
+ingress routers of the appropriate encapsulation information to use
+with each of the given protocol types.  Insertion of the specified
+Session ID at the ingress routers allows the egress to process the
+incoming packets correctly, according to their protocol type.
+
+
+
+TLVs
+
+L2TPv3  type = 1
+GRE = 2
+IP in IP = 7
+
+Sub-TLVs
+
+- Encapsulation: sub-TLV type = 1
+
+  encap_l2tpv3 : session_id(4) + coockie(v)
+  encap_gre: key(4)
+
+- Protocol type: sub-TLV tye =2
+
+  ethertype(2)
+
+  For example, if we want to use three L2TPv3 sessions, one carrying
+  IPv4 packets, one carrying IPv6 packets, and one carrying MPLS
+  packets, the egress router will include three TLVs of L2TPv3
+  encapsulation type, each specifying a different Session ID and a
+  different payload type.  The protocol type sub-TLV for these will be
+  IPv4 (protocol type = 0x0800), IPv6 (protocol type = 0x86dd), and
+  MPLS (protocol type = 0x8847), respectively.  This informs the
+  ingress routers of the appropriate encapsulation information to use
+  with each of the given protocol types.  Insertion of the specified
+  Session ID at the ingress routers allows the egress to process the
+  incoming packets correctly, according to their protocol type.
+
+  Inclusion of this sub-TLV depends on the tunnel type.  It MUST be
+  encoded for L2TPv3 tunnel type.  On the other hand, the protocol type
+  sub-TLV is not required for IP in IP or GRE tunnels.
+
+
+- Protocol type: sub-TLV type = 2
+- Color: sub-TLV type = 4
+
+
+
+4.  Tunnel Encapsulation Attribute
+
+   The Tunnel Encapsulation attribute is an optional transitive
+   attribute that is composed of a set of Type-Length-Value (TLV)
+   encodings.  The type code of the attribute is 23.  Each TLV contains
+   information corresponding to a particular tunnel technology.  The TLV
+   is structured as follows:
+
+       0                   1                   2                   3
+       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |    Tunnel Type (2 Octets)     |        Length (2 Octets)      |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                                                               |
+      |                             Value                             |
+      |                                                               |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+   * Tunnel Type (2 octets): identifies the type of tunneling technology
+     being signaled.  This document defines the following types:
+
+     - L2TPv3 over IP [RFC3931]: Tunnel Type = 1
+     - GRE [RFC2784]: Tunnel Type = 2
+     - IP in IP [RFC2003] [RFC4213]: Tunnel Type = 7
+
+     Unknown types are to be ignored and skipped upon receipt.
+
+   * Length (2 octets): the total number of octets of the value field.
+
+   * Value (variable): comprised of multiple sub-TLVs.  Each sub-TLV
+     consists of three fields: a 1-octet type, 1-octet length, and zero
+     or more octets of value.  The sub-TLV is structured as follows:
+
+
+
+
+Mohapatra & Rosen           Standards Track                     [Page 5]
+ 
+RFC 5512    BGP Encapsulation SAFI and Tunnel Encapsulation   April 2009
+
+
+                     +-----------------------------------+
+                     |      Sub-TLV Type (1 Octet)       |
+                     +-----------------------------------+
+                     |     Sub-TLV Length (1 Octet)      |
+                     +-----------------------------------+
+                     |     Sub-TLV Value (Variable)      |
+                     |                                   |
+                     +-----------------------------------+
+
+   * Sub-TLV Type (1 octet): each sub-TLV type defines a certain
+     property about the tunnel TLV that contains this sub-TLV.  The
+     following are the types defined in this document:
+
+     - Encapsulation: sub-TLV type = 1
+     - Protocol type: sub-TLV type = 2
+     - Color: sub-TLV type = 4
+
+     When the TLV is being processed by a BGP speaker that will be
+     performing encapsulation, any unknown sub-TLVs MUST be ignored and
+     skipped.  However, if the TLV is understood, the entire TLV MUST
+     NOT be ignored just because it contains an unknown sub-TLV.
+
+   * Sub-TLV Length (1 octet): the total number of octets of the sub-TLV
+     value field.
+
+   * Sub-TLV Value (variable): encodings of the value field depend on
+     the sub-TLV type as enumerated above.  The following sub-sections
+     define the encoding in detail.
+
+4.1.  Encapsulation Sub-TLV
+
+   The syntax and semantics of the encapsulation sub-TLV is determined
+   by the tunnel type of the TLV that contains this sub-TLV.
+
+   When the tunnel type of the TLV is L2TPv3 over IP, the following is
+   the structure of the value field of the encapsulation sub-TLV:
+
+       0                   1                   2                   3
+       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                      Session ID (4 octets)                    |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                                                               |
+      |                        Cookie (Variable)                      |
+      |                                                               |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+
+
+
+Mohapatra & Rosen           Standards Track                     [Page 6]
+ 
+RFC 5512    BGP Encapsulation SAFI and Tunnel Encapsulation   April 2009
+
+
+   * Session ID: a non-zero 4-octet value locally assigned by the
+     advertising router that serves as a lookup key in the incoming
+     packet's context.
+
+   * Cookie: an optional, variable length (encoded in octets -- 0 to 8
+     octets) value used by L2TPv3 to check the association of a received
+     data message with the session identified by the Session ID.
+     Generation and usage of the cookie value is as specified in
+     [RFC3931].
+
+     The length of the cookie is not encoded explicitly, but can be
+     calculated as (sub-TLV length - 4).
+
+   When the tunnel type of the TLV is GRE, the following is the
+   structure of the value field of the encapsulation sub-TLV:
+
+       0                   1                   2                   3
+       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                      GRE Key (4 octets)                       |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+   * GRE Key: 4-octet field [RFC2890] that is generated by the
+     advertising router.  The actual method by which the key is obtained
+     is beyond the scope of this document.  The key is inserted into the
+     GRE encapsulation header of the payload packets sent by ingress
+     routers to the advertising router.  It is intended to be used for
+     identifying extra context information about the received payload.
+
+     Note that the key is optional.  Unless a key value is being
+     advertised, the GRE encapsulation sub-TLV MUST NOT be present.
+
+4.2.  Protocol Type Sub-TLV
+
+   The protocol type sub-TLV MAY be encoded to indicate the type of the
+   payload packets that will be encapsulated with the tunnel parameters
+   that are being signaled in the TLV.  The value field of the sub-TLV
+   contains a 2-octet protocol type that is one of the types defined in
+   [IANA-AF] as ETHER TYPEs.
+
+   For example, if we want to use three L2TPv3 sessions, one carrying
+   IPv4 packets, one carrying IPv6 packets, and one carrying MPLS
+   packets, the egress router will include three TLVs of L2TPv3
+   encapsulation type, each specifying a different Session ID and a
+   different payload type.  The protocol type sub-TLV for these will be
+   IPv4 (protocol type = 0x0800), IPv6 (protocol type = 0x86dd), and
+   MPLS (protocol type = 0x8847), respectively.  This informs the
+   ingress routers of the appropriate encapsulation information to use
+   with each of the given protocol types.  Insertion of the specified
+   Session ID at the ingress routers allows the egress to process the
+   incoming packets correctly, according to their protocol type.
+
+   Inclusion of this sub-TLV depends on the tunnel type.  It MUST be
+   encoded for L2TPv3 tunnel type.  On the other hand, the protocol type
+   sub-TLV is not required for IP in IP or GRE tunnels.
+
+4.3.  Color Sub-TLV
+
+   The color sub-TLV MAY be encoded as a way to color the corresponding
+   tunnel TLV.  The value field of the sub-TLV contains an extended
+   community that is defined as follows:
+
+4.3.1.  Color Extended Community
+
+   The Color Extended Community is an opaque extended community
+   [RFC4360] with the following encoding:
+
+           0                   1                   2                   3
+           0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+          |       0x03    |     0x0b      |           Reserved            |
+          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+          |                          Color Value                          |
+          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+   The value of the high-order octet of the extended type field is 0x03,
+   which indicates it is transitive.  The value of the low-order octet
+   of the extended type field for this community is 0x0b.  The color
+   value is user defined and configured locally on the routers.  The
+   same Color Extended Community can then be attached to the UPDATE
+   messages that contain payload prefixes.  This way, the BGP speaker
+   can express the fact that it expects the packets corresponding to
+   these payload prefixes to be received with a particular tunnel
+   encapsulation header.
+
+