ospfv2 0.0.2 → 0.0.3

data/test/unit/ie/opaque_type_test.rb

@@ -0,0 +1,22 @@
+
+require "test/unit"
+require 'ie/opaque_type'
+
+
+class TestIeLsType < Test::Unit::TestCase
+  include OSPFv2
+  def test_new
+    assert OpaqueType.new
+    assert_equal 'OpaqueType: te_lsa', OpaqueType.new.to_s
+    assert_equal 'OpaqueType: te_lsa', OpaqueType.new(:te_lsa).to_s
+    assert_equal 'OpaqueType: grace_lsa', OpaqueType.new(:grace_lsa).to_s
+    assert_equal [1], OpaqueType.new.encode.unpack('C')
+    assert_equal [1], OpaqueType.new(:te_lsa).encode.unpack('C')
+    assert_equal [1], OpaqueType.new(1).encode.unpack('C')
+    assert_equal [3], OpaqueType.new(:grace_lsa).encode.unpack('C')
+    assert_equal [3], OpaqueType.new(3).encode.unpack('C')
+    assert_equal :te_lsa, OpaqueType.new(1).to_sym
+    assert_equal :grace_lsa, OpaqueType.new(3).to_sym
+  end
+end
+

data/test/unit/ie/options_test.rb

@@ -0,0 +1,142 @@
+#
+#  Created by Jean-Michel Esnault.
+#  Copyright (c) 2008. All rights reserved.
+#
+
+require 'test/unit'
+require 'pp'
+require 'ie/options'
+
+class TestOptions < Test::Unit::TestCase # :nodoc:
+  include OSPFv2
+  def test_dc_bit
+    assert_equal("Options:  0x20  [DC]", Options.new({:DC=>1}).to_s)
+    assert_equal("Options:  0x20  [DC]", Options.new({:dc=>1}).to_s)
+    assert_equal(32, Options.new({:DC=>true}).options)
+    assert_equal(32, Options.new({:dc=>true}).options)
+    assert_equal(true, Options.new({:dc=>true}).dc?)
+    assert_equal(0, Options.new({:DC=>0}).options)
+    assert_equal(0, Options.new({:dc=>0}).options)
+    assert_equal(0, Options.new({:DC=>false}).options)
+    assert_equal(0, Options.new({:dc=>false}).options)
+    assert_equal(false, Options.new({:dc=>false}).dc?)
+  end
+  def test_l_bit
+    assert_equal("Options:  0x10  [L]", Options.new({:L=>1}).to_s)
+    assert_equal("Options:  0x10  [L]", Options.new({:l=>1}).to_s)
+    assert_equal(16, Options.new({:L=>true}).options)
+    assert_equal(16, Options.new({:l=>true}).options)
+    assert_equal(true, Options.new({:l=>true}).l?)
+    assert_equal(0, Options.new({:L=>0}).options)
+    assert_equal(0, Options.new({:l=>0}).options)
+    assert_equal(0, Options.new({:L=>false}).options)
+    assert_equal(0, Options.new({:l=>false}).options)
+    assert_equal(false, Options.new({:l=>false}).l?)
+  end
+  def test_n_bit
+    assert_equal("Options:  0x8  [N]", Options.new({:N=>1}).to_s)
+    assert_equal("Options:  0x8  [N]", Options.new({:n=>1}).to_s)
+    assert_equal(8, Options.new({:N=>true}).options)
+    assert_equal(8, Options.new({:n=>true}).options)
+    assert_equal(true, Options.new({:n=>true}).n?)
+    assert_equal(true, Options.new({:p=>true}).p?)
+    assert_equal(0, Options.new({:N=>0}).options)
+    assert_equal(0, Options.new({:n=>0}).options)
+    assert_equal(0, Options.new({:N=>false}).options)
+    assert_equal(0, Options.new({:n=>false}).options)
+    assert_equal(false, Options.new({:n=>false}).n?)
+  end
+  def test_mc_bit
+    assert_equal("Options:  0x4  [MC]", Options.new({:MC=>1}).to_s)
+    assert_equal("Options:  0x4  [MC]", Options.new({:mc=>1}).to_s)
+    assert_equal(4, Options.new({:MC=>true}).options)
+    assert_equal(4, Options.new({:mc=>true}).options)
+    assert_equal(true, Options.new({:mc=>true}).mc?)
+    assert_equal(0, Options.new({:MC=>0}).options)
+    assert_equal(0, Options.new({:mc=>0}).options)
+    assert_equal(0, Options.new({:MC=>false}).options)
+    assert_equal(0, Options.new({:mc=>false}).options)
+    assert_equal(false, Options.new({:mc=>false}).mc?)
+  end
+  def test_e_bit
+    assert_equal("Options:  0x2  [E]", Options.new({:E=>1}).to_s)
+    assert_equal("Options:  0x2  [E]", Options.new({:e=>1}).to_s)
+    assert_equal(2, Options.new({:E=>true}).options)
+    assert_equal(2, Options.new({:e=>true}).options)
+    assert_equal(true, Options.new({:e=>true}).e?)
+    assert_equal(0, Options.new({:E=>0}).options)
+    assert_equal(0, Options.new({:e=>0}).options)
+    assert_equal(0, Options.new({:E=>false}).options)
+    assert_equal(0, Options.new({:e=>false}).options)
+    assert_equal(false, Options.new({:e=>false}).e?)
+  end
+  def test_v6_bit
+    assert_equal("Options:  0x1  [V6]", Options.new({:V6=>1}).to_s)
+    assert_equal("Options:  0x1  [V6]", Options.new({:v6=>1}).to_s)
+    assert_equal(1, Options.new({:V6=>true}).options)
+    assert_equal(1, Options.new({:v6=>true}).options)
+    assert_equal(true, Options.new({:v6=>true}).v6?)
+    assert_equal(0, Options.new({:V6=>0}).options)
+    assert_equal(0, Options.new({:v6=>0}).options)
+    assert_equal(0, Options.new({:V6=>false}).options)
+    assert_equal(0, Options.new({:v6=>false}).options)
+    assert_equal(false, Options.new({:v6=>false}).v6?)
+  end
+  def test_opaque_bit
+    assert_equal("Options:  0x40  [O]", Options.new({:O=>1}).to_s)
+    assert_equal("Options:  0x40  [O]", Options.new({:o=>1}).to_s)
+    assert_equal(64, Options.new({:O=>true}).options)
+    assert_equal(64, Options.new({:o=>true}).options)
+    assert_equal(true, Options.new({:o=>true}).o?)
+    assert_equal(0, Options.new({:O=>0}).options)
+    assert_equal(0, Options.new({:o=>0}).options)
+    assert_equal(0, Options.new({:o=>false}).options)
+    assert_equal(0, Options.new({:o=>false}).options)
+    assert_equal(false, Options.new({:o=>false}).o?)
+  end
+  def test_set_multi_bit
+    opt = Options.new
+    opt.setDC 
+    assert_equal("Options:  0x20  [DC]", opt.to_s)
+    opt.setL
+    assert_equal("Options:  0x30  [L,DC]", opt.to_s)
+    opt.setN
+    assert_equal("Options:  0x38  [L,DC,N]", opt.to_s)
+    opt.setMC
+    assert_equal("Options:  0x3c  [L,DC,N,MC]", opt.to_s)
+    opt.setE
+    assert_equal("Options:  0x3e  [L,DC,N,MC,E]", opt.to_s)
+    opt.setV6
+    assert_equal("Options:  0x3f  [L,DC,N,MC,E,V6]", opt.to_s)
+    opt = Options.new
+    opt.setDC << opt.setV6 << opt.setMC
+    assert_equal("Options:  0x25  [DC,MC,V6]", opt.to_s)
+  end
+  def test_unset_multi_bit
+    opt = Options.new
+    opt.options=0x7f
+    assert_equal("Options:  0x7f  [O,L,DC,N,MC,E,V6]", opt.to_s)
+    opt.unsetE << opt.unsetMC
+    assert_equal("Options:  0x79  [O,L,DC,N,V6]", opt.to_s)
+    opt.unsetDC << opt.unsetL << opt.unsetO
+    assert_equal("Options:  0x9  [N,V6]", opt.to_s)
+    opt.unsetV6 << opt.unsetN
+    assert_equal(0, opt.options)
+  end
+  def test_set_nssa
+    opt = Options.new
+    opt.setE 
+    assert_equal("Options:  0x2  [E]", opt.to_s)
+    opt.setNSSA 
+    assert_equal("Options:  0x8  [N]", opt.to_s)
+  end
+
+  def test_enc
+    opt = Options.new([0x3f].pack('C'))
+    assert_equal("Options:  0x3f  [L,DC,N,MC,E,V6]", opt.to_s)
+    assert_equal(true, opt.dc?)
+    assert_equal(true, opt.e?)
+    assert_equal("3f", opt.to_shex)
+  end
+
+end

data/test/unit/ie/packet_type_test.rb

@@ -0,0 +1,33 @@
+
+require "test/unit"
+require 'ie/packet_type'
+
+
+class TestPacketType < Test::Unit::TestCase
+  include OSPFv2
+  def test_new
+    assert PacketType.new
+    assert_equal 'PacketType: hello', PacketType.new(:hello).to_s
+    assert_equal 'PacketType: dd', PacketType.new(:dd).to_s
+    assert_equal 'PacketType: ls_request', PacketType.new(:ls_request).to_s
+    assert_equal 'PacketType: ls_update', PacketType.new(:ls_update).to_s
+    assert_equal 'PacketType: ls_ack', PacketType.new(:ls_ack).to_s
+    assert_equal :hello, PacketType.new(:hello).to_sym
+    assert_equal 1, PacketType.new(:hello).to_i
+    assert_equal 2, PacketType.new(:dd).to_i
+    assert_equal 3, PacketType.new(:ls_request).to_i
+    assert_equal 4, PacketType.new(:ls_update).to_i
+    assert_equal 5, PacketType.new(:ls_ack).to_i
+    assert_equal 1, PacketType.new(1).to_i
+    assert_equal 2, PacketType.new(2).to_i
+    assert_equal 3, PacketType.new(3).to_i
+    assert_equal 4, PacketType.new(4).to_i
+    assert_equal 5, PacketType.new(5).to_i
+    assert_equal :hello, PacketType.new(:hello).to_sym
+    assert_equal :dd, PacketType.new(:dd).to_sym
+    assert_equal :ls_request, PacketType.new(:ls_request).to_sym
+    assert_equal :ls_update, PacketType.new(:ls_update).to_sym
+    assert_equal :ls_ack, PacketType.new(:ls_ack).to_sym
+  end
+end
+

data/test/unit/ie/router_link_factory_test.rb

@@ -0,0 +1,26 @@
+require "test/unit"
+require "ie/router_link_factory"
+
+class TestIeRouterLinkFactory < Test::Unit::TestCase
+  include OSPFv2
+  def tests
+    assert_equal RouterLink::PointToPoint,   (l1=RouterLink.factory(['000000000000000001000000'].pack('H*'))).class
+    assert_equal RouterLink::StubNetwork,    (l2=RouterLink.factory(['000000000000000003000000'].pack('H*'))).class
+    assert_equal RouterLink::VirtualLink,    (l3=RouterLink.factory(['000000000000000004000000'].pack('H*'))).class
+    assert_equal RouterLink::TransitNetwork, (l4=RouterLink.factory(['000000000000000002000000'].pack('H*'))).class
+    assert_equal RouterLink::TransitNetwork, (l5=RouterLink.factory(['0000000000000000020100000a000014'].pack('H*'))).class
+    assert_raise(ArgumentError) { RouterLink.factory(:link_id=> '1.1.1.1') }
+    assert_equal RouterLink::PointToPoint, RouterLink.factory(:link_data=> '1.1.1.1', :router_link_type => :point_to_point).class
+    assert_equal RouterLink::TransitNetwork, RouterLink.factory(:link_data=> '1.1.1.1', :router_link_type => :transit_network).class
+    assert_equal RouterLink::StubNetwork, RouterLink.factory(:link_data=> '1.1.1.1', :router_link_type => :stub_network).class
+    assert_equal RouterLink::VirtualLink, RouterLink.factory(:link_data=> '1.1.1.1', :router_link_type => :virtual_link).class
+    l1h = RouterLink.factory :router_link_type=>:point_to_point, :metric=>0, :tos_metrics=>[], :link_id=>"0.0.0.0", :link_data=>"0.0.0.0"
+    assert_equal l1h.to_shex , l1.to_shex
+    l1h = RouterLink.factory :router_link_type=>:point_to_point,  :tos_metrics=>[], :link_id=>"0.0.0.0", :link_data=>"0.0.0.0"
+    assert_equal l1.to_shex, l1h.to_shex 
+    l1h = RouterLink::PointToPoint.new :router_link_type=>:point_to_point,  :tos_metrics=>[], :link_id=>"0.0.0.0", :link_data=>"0.0.0.0"
+    assert_equal l1.to_shex, l1h.to_shex
+    assert_equal l1.to_hash, l1h.to_hash
+  end
+end
+

data/test/unit/ie/router_link_test.rb

@@ -0,0 +1,276 @@
+require "test/unit"
+require "ie/router_link"
+require 'ie/router_link_factory'
+class TestIeRouterLink < Test::Unit::TestCase
+  include OSPFv2
+  def tests
+    assert RouterLink.new
+    assert_equal '000000000000000001000000', RouterLink.new.to_shex
+    assert_equal 4*3, RouterLink.new.encode.size
+    assert_equal '', RouterLink.new.router_link_type.to_s
+    assert_equal '010101010000000001000000', RouterLink.new( :link_id=> '1.1.1.1').to_shex
+    assert_equal '01010101ffffffff01000000',
+                  RouterLink.new( :link_id=> '1.1.1.1', :link_data=> '255.255.255.255').to_shex
+    assert_equal '01010101ffffffff0100000a',
+                RouterLink.new( :link_id=> '1.1.1.1', :link_data=> '255.255.255.255', :metric=>10).to_shex
+    assert_equal '01010101ffffffff0101000a0a000014',
+                RouterLink.new( :link_id=> '1.1.1.1', 
+                                :link_data=> '255.255.255.255', 
+                                :metric=>10, 
+                                :mt_metrics =>{ :id=>10, :metric=>20}).to_shex
+    assert_equal '01010101ffffffff0102000a0a0000140b00001e',
+                RouterLink.new( :link_id=> '1.1.1.1', 
+                                :link_data=> '255.255.255.255', 
+                                :metric=>10, 
+                                :mt_metrics => [{:id=>10, :metric=>20},{:id=>11, :metric=>30}]
+                                ).to_shex
+    
+    assert_equal '010101010000000001000000', RouterLink.new(:link_id=> '1.1.1.1').to_shex
+    assert_equal '000000000101010101000000', RouterLink.new(:link_data=> '1.1.1.1').to_shex
+    assert_equal '020202020101010101000000', RouterLink.new(:link_data=> '1.1.1.1', :link_id=>'2.2.2.2').to_shex
+    assert_equal '02020202010101010100000a', RouterLink.new(:link_data=> '1.1.1.1', :link_id=>'2.2.2.2', :metric=>10).to_shex
+    assert_equal '02020202010101010101000a0a000014', 
+          RouterLink.new(:link_data=> '1.1.1.1', :link_id=>'2.2.2.2', :metric=>10, :mt_metrics =>{ :id=>10, :metric=>20}).to_shex
+    
+    h = {
+      :link_id=> '1.1.1.1', 
+      :link_data=> '255.255.255.255', 
+      :metric=>10, 
+      :mt_metrics => [{:id=>10, :metric=>20},{:id=>11, :metric=>30}]
+    }    
+    assert_equal(h, RouterLink.new(h).to_hash)
+    assert RouterLink::PointToPoint.new({})
+    assert_equal '000000000000000001000000', RouterLink::PointToPoint.new({}).to_shex
+    assert_equal '000000000000000003000000', RouterLink::StubNetwork.new({}).to_shex
+    assert_equal '000000000000000004000000', RouterLink::VirtualLink.new({}).to_shex
+    assert_equal '000000000000000002000000', RouterLink::TransitNetwork.new({}).to_shex
+    assert_equal '010101010000000001000000', RouterLink::PointToPoint.new(:link_id=>'1.1.1.1').to_shex
+    assert_equal '000000000202020203000000', RouterLink::StubNetwork.new(:link_data=>'2.2.2.2').to_shex
+    assert_equal '00000000000000000400abcd', RouterLink::VirtualLink.new(:metric=>0xabcd).to_shex
+    assert_equal '0000000000000000020100000a000014', 
+          RouterLink::TransitNetwork.new(:mt_metrics =>{ :id=>10, :metric=>20}).to_shex
+    
+    assert_equal '000000000000000001000000', RouterLink.new(['000000000000000001000000'].pack('H*')).to_shex
+    assert_equal '000000000000000003000000', RouterLink.new(['000000000000000003000000'].pack('H*')).to_shex
+    assert_equal '000000000000000004000000', RouterLink.new(['000000000000000004000000'].pack('H*')).to_shex
+    assert_equal '000000000000000002000000', RouterLink.new(['000000000000000002000000'].pack('H*')).to_shex
+    assert_equal '0000000000000000020100000a000014', RouterLink.new(['0000000000000000020100000a000014'].pack('H*')).to_shex
+    
+  end
+  
+  def test_point_2_point
+    
+    
+    
+    # puts RouterLink::PointToPoint.new(:link_data=> '2.2.2.2', :link_id=>'1.1.1.1').to_s
+    # puts RouterLink::PointToPoint.new(:link_data=> '2.2.2.2', :link_id=>'1.1.1.1').to_s_junos
+    # puts RouterLink::PointToPoint.new(:link_data=> '2.2.2.2', :link_id=>'1.1.1.1').to_s_ios
+    # 
+
+
+
+
+
+  end
+  
+  
+  
+  def test_misc
+    h = {:router_link_type=>3, :metric=>1, :link_data=>"255.255.255.240", :link_id=>"192.168.8.0"}
+    assert_equal "c0a80800fffffff003000001", RouterLink.factory(h).to_shex
+    h = {:router_link_type=>1, :metric=>1,:mt_metrics=>[{:id=>15, :metric=>14}, {:id=>13, :metric=>12}], :link_data=>"10.254.233.233",:link_id=>"2.2.2.2"}
+    assert_equal "020202020afee9e9010200010f00000e0d00000c", RouterLink.factory(h).to_shex
+  end
+  
+  def test_tos_metric
+    h = {:router_link_type=>1, :metric=>1, :link_data=>"10.254.233.233",:link_id=>"2.2.2.2"}
+    rlink = RouterLink.factory(h)
+    rlink << [33,20]
+    rlink << [34,255]
+    assert_equal "020202020afee9e90102000121000014220000ff", rlink.to_shex
+    rlink = RouterLink.new(h)
+    rlink << MtMetric.new([33,20])
+    rlink << MtMetric.new([34,255])
+    assert_equal("020202020afee9e90102000121000014220000ff", rlink.to_shex)
+    rlink = RouterLink.new(h)
+    rlink << [33,20] << [34,255]
+    assert_equal("020202020afee9e90102000121000014220000ff", rlink.to_shex)
+    rlink = RouterLink.new(h)
+    assert_raise(ArgumentError) { rlink << [33] }
+    assert_raise(ArgumentError) { rlink << [33,100,1] }
+  end
+  
+  def test_router_link_p2p
+    h = {:metric=>1, :link_data=>"255.255.255.240", :link_id=>"192.168.8.0"}
+    assert_equal "PointToPoint:\n    LinkId: 192.168.8.0\n    LinkData: 255.255.255.240\n    RouterLinkType: point_to_point\n    Metric: 1",
+              RouterLink::PointToPoint.new(h).to_s
+    assert_equal "c0a80800fffffff001000001", RouterLink::PointToPoint.new(h).to_shex
+    assert_equal(:point_to_point, RouterLink::PointToPoint.new(h).to_hash[:router_link_type])
+    assert_equal(1, RouterLink::PointToPoint.new(h).to_hash[:metric])
+    assert_equal("255.255.255.240", RouterLink::PointToPoint.new(h).to_hash[:link_data])
+    assert_equal("192.168.8.0", RouterLink::PointToPoint.new(h).to_hash[:link_id])
+    assert_equal( RouterLink::PointToPoint.new(h).encode, RouterLink::PointToPoint.new( RouterLink::PointToPoint.new(h)).encode)
+  end
+  
+  def test_new_from_hash
+    h = {:metric=>1, :link_data=>"255.255.255.240", :link_id=>"192.168.8.0"}
+    assert_equal RouterLink::PointToPoint, RouterLink.new_point_to_point(h).class
+    assert_equal RouterLink::StubNetwork, RouterLink.new_stub_network(h).class
+    assert_equal RouterLink::TransitNetwork, RouterLink.new_transit_network(h).class
+    assert_equal RouterLink::VirtualLink, RouterLink.new_virtual_link(h).class
+  end
+  
+  def test_to_s
+    h = {:metric=>1, :link_data=>"255.255.255.240", :link_id=>"192.168.8.0",
+      :mt_metrics => [{:id=>10, :metric=>20},{:id=>11, :metric=>30}]}
+    assert_match( /PointToPoint:\n    LinkId: 192.168.8.0\n/  ,RouterLink.new_point_to_point(h).to_s)
+    assert_match( /LinkData: 255.255.255.240\n/,RouterLink.new_point_to_point(h).to_s)
+    assert_match( /RouterLinkType: point_to_point\n    Metric: 1/,RouterLink.new_point_to_point(h).to_s)
+  end
+  
+  # id 0.0.0.2, data 192.168.2.1, Type PointToPoint (1)
+  #   Topology count: 0, Default metric: 2
+  # id 192.168.2.0, data 255.255.255.0, Type Stub (3)
+  #   Topology count: 0, Default metric: 2
+  # id 0.0.0.3, data 192.168.3.1, Type PointToPoint (1)
+  #   Topology count: 0, Default metric: 2
+  # id 192.168.3.0, data 255.255.255.0, Type Stub (3)
+  #   Topology count: 0, Default metric: 2
+  # id 0.0.0.4, data 192.168.4.1, Type PointToPoint (1)
+  #   Topology count: 0, Default metric: 2
+  # id 192.168.4.0, data 255.255.255.0, Type Stub (3)
+  #   Topology count: 0, Default metric: 2
+  # 
+  def test_to_s_junos
+    h_link1 = {:router_link_type=>1, :metric=>1, :link_data=>"255.255.255.240", :link_id=>"192.168.8.0"}
+    h_link2 = {:router_link_type=>2, :metric=>1, :link_data=>"255.255.255.240", :link_id=>"192.168.8.0"}
+    h_link3 = {:router_link_type=>3, :metric=>1, :link_data=>"255.255.255.240", :link_id=>"192.168.8.0"}
+    assert_equal("  id 192.168.8.0, data 255.255.255.240, Type Point-to-point (1)\n    Topology count: 0, Default metric: 1", RouterLink.new(h_link1).to_s_junos)
+    assert_equal("  id 192.168.8.0, data 255.255.255.240, Type Transit (2)\n    Topology count: 0, Default metric: 1", RouterLink.new(h_link2).to_s_junos)
+    assert_equal("  id 192.168.8.0, data 255.255.255.240, Type Stub (3)\n    Topology count: 0, Default metric: 1", RouterLink.new(h_link3).to_s_junos)
+    h = {
+       :router_link_type => 2,
+       :link_id=> '1.1.1.1', 
+       :link_data=> '255.255.255.255', 
+       :metric=>10, 
+       :mt_metrics => [{:id=>10, :metric=>20},{:id=>11, :metric=>30}]
+     }    
+     
+     # puts ""
+     # puts RouterLink.new(h).to_s_junos
+     assert_equal("  id 1.1.1.1, data 255.255.255.255, Type Transit (2)\n    Topology count: 2, Default metric: 10\n    Topology 10, Metric 20\n    Topology 11, Metric 30", RouterLink.new(h).to_s_junos)
+  end
+  
+
+end
+
+__END__
+
+
+
+            OSPF Router with ID (1.1.1.1) (Process ID 1)
+
+                Router Link States (Area 0)
+
+  LS age: 1701
+  Options: (No TOS-capability, DC)
+  LS Type: Router Links
+  Link State ID: 1.1.1.1
+  Advertising Router: 1.1.1.1
+  LS Seq Number: 80000015
+  Checksum: 0xEEBC
+  Length: 84
+  Number of Links: 5
+
+    Link connected to: another Router (point-to-point)
+     (Link ID) Neighboring Router ID: 0.0.0.1
+     (Link Data) Router Interface address: 192.168.158.13
+      Number of TOS metrics: 0
+       TOS 0 Metrics: 1
+
+    Link connected to: a Stub Network
+     (Link ID) Network/subnet number: 192.168.158.0
+     (Link Data) Network Mask: 255.255.255.0
+      Number of TOS metrics: 0
+       TOS 0 Metrics: 1
+
+    Link connected to: a Transit Network
+     (Link ID) Designated Router address: 192.168.0.2
+     (Link Data) Router Interface address: 192.168.0.1
+      Number of TOS metrics: 0
+       TOS 0 Metrics: 10
+
+    Link connected to: a Stub Network
+     (Link ID) Network/subnet number: 20.0.0.3
+     (Link Data) Network Mask: 255.255.255.255
+      Number of TOS metrics: 0
+       TOS 0 Metrics: 1
+
+    Link connected to: a Stub Network
+     (Link ID) Network/subnet number: 20.0.0.1
+     (Link Data) Network Mask: 255.255.255.255
+      Number of TOS metrics: 0
+       TOS 0 Metrics: 1
+
+
+R1#
+
+
+
+LS age: 22
+Options:  0x22  [DC,E]
+LS Type: Router Links
+Link State ID: 1.1.1.1
+Advertising Router: 1.1.1.1
+LS Seq Number: 80000019
+Checksum: 0xE6C0
+Length: 84
+Number of Links: 5
+
+  Link connected to: another Router (point-to-point)
+    (Link ID) Neighboring Router ID: 0.0.0.1
+    (Link Data) Router Interface address: 192.168.158.13
+  
+   
+  Link connected to: a Stub Network
+    (Link ID) Network/subnet number: 192.168.158.0
+    (Link Data) Network Mask: 255.255.255.0
+  
+   
+  Link connected to: a Transit Network
+    (Link ID) Designated Router address: 192.168.0.2
+    (Link Data) Router Interface address: 192.168.0.1
+  
+   
+  Link connected to: a Stub Network
+    (Link ID) Network/subnet number: 20.0.0.3
+    (Link Data) Network Mask: 255.255.255.255
+  
+   
+  Link connected to: a Stub Network
+    (Link ID) Network/subnet number: 20.0.0.1
+    (Link Data) Network Mask: 255.255.255.255
+  
+
+
+
+
+    LS Seq Number: 80000001
+    Checksum: 0xEC8D
+    Length: 72
+    Number of Links: 4
+
+      Link connected to: another Router (point-to-point)
+        (Link ID) Neighboring Router ID: 1.1.1.1
+        (Link Data) Router Interface address: 192.168.158.1
+         Number of TOS metrics: 0
+         TOS 0 Metrics: 1
+
+
+      Link connected to: a Stub Network
+        (Link ID) Network/subnet number: 192.168.158.1
+        (Link Data) Network Mask: 255.255.255.255
+         Number of TOS metrics: 0
+         TOS 0 Metrics: 1
+
+