netaddr 2.0.4 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de26482bcd44b80695dd256c99f45c9f5ceb4d7bec3cfc57c60a0f59a860188d
-  data.tar.gz: f86ab761fd9ab76f1de6f1fb26d4f89fa85390ab772c3144de18d07b5202dc0e
+  metadata.gz: 9a1415cbc9b4353fc9da565edf3ac8a7a9e0494e9a69d5767c1a46219abc4b24
+  data.tar.gz: d6d34f2d5dff1beea5855bfac31d5bbb12a3358f8f12aee2513dc074047037d7
 SHA512:
-  metadata.gz: e5afb658aa8805f286b273ada3a86fae37b6fd8c4e6ef441845e78fa70e351c7c9b2df2b84f8e919a5cea032ad801b0f1fe36494e13b8e9b3afcf7ecd2ac869b
-  data.tar.gz: 339ba4279b2f90223362c40ca5753922b889bf2cc2870c4a7a9ddd774668ad7dd419144a9773bd371a5ca16e6d77b7465756fcf5f46bf2410effbbc3a1dc0e55
+  metadata.gz: fb448e9527d5bca2ec9c8f095dcf6b825de2919a429bf6aa50b757b2b71dcc9778b2910a090fbba3af209349f295ab59df29cb95f76057400e16a6b9eb892e93
+  data.tar.gz: b2ff3dffd33f4bc1ce5b0e1fc16f3121cb2a7f75d9a0a6321daf7c1cc7adea85224d1bb1d0a4593706d0125341fa0c82c464a5ed8d3d5f34de79721df0dcf5ac

data/lib/ipv6.rb

@@ -40,6 +40,31 @@ module NetAddr
 			return 0
 		end
 		
+		# ipv4 generates an IPv4 from an IPv6 address. The IPv4 address is generated based on the mechanism described by RFC 6052.
+		# The argument pl (prefix length) should be one of: 32, 40, 48, 56, 64, or 96. Default is 96 unless one of the supported values is provided.
+		def ipv4(pl=96)
+			if (pl == 32)
+				i = (@addr >> 64) # get bits 32-63 into position
+				return IPv4.new(i & NetAddr::F32)
+			elsif (pl == 40)
+				i = (@addr >> 48) & 0xff # get the last 8 bits into position
+				i2 = (@addr & 0xffffff0000000000000000) >> 56 # get first 24 bits into position
+				return IPv4.new(i | i2)
+			elsif (pl == 48)
+				i = (@addr >> 40) & 0xffff # get the last 16 bits into position
+				i2 = (@addr & 0xffff0000000000000000) >> 48 # get first 16 bits into position
+				return IPv4.new(i | i2)
+			elsif (pl == 56)
+				i = (@addr >> 32) & 0xffffff # get the last 24 bits into position
+				i2 = (@addr & 0xff0000000000000000) >> 40 # get first 8 bits into position
+				return IPv4.new(i | i2)
+			elsif (pl == 64)
+				i = (@addr >> 24) # get the 32 bits into position
+				return IPv4.new(i & NetAddr::F32)
+			end
+			return IPv4.new(@addr & NetAddr::F32)
+		end
+		
 		# long returns the IPv6 as a string in long (uncompressed) format
 		def long()
 			words = []
@@ -100,8 +125,9 @@ module NetAddr
 				end
 			end
 			
-			# compress if we've found a series of 0 words in a row
-			if (finalStart != -1)
+			# compress if we've found a series of zero fields in a row.
+      # per https://tools.ietf.org/html/rfc5952#section-4.2.2 we must not compress just a single 16-bit zero field.
+			if (finalLen > 1)
 				head = hexStr[0,finalStart].join(":")
 				tailStart = finalStart + finalLen 
 				tail = hexStr[tailStart..7].join(":")

data/lib/netaddr.rb

@@ -39,10 +39,10 @@ module NetAddr
 	
 	## parse_ip parses a string into an IPv4 or IPv6
 	def parse_ip(ip)
-		if (ip.include?(".")) # ipv4
-			return IPv4.parse(ip)
+		if (ip.include?(":"))
+			return IPv6.parse(ip)
 		end
-		return IPv6.parse(ip)
+		return IPv4.parse(ip)
 	end
 	module_function :parse_ip
 	

data/lib/util.rb

@@ -49,7 +49,7 @@ module NetAddr
 	# fill returns a copy of the given Array, stripped of any networks which are not subnets of ipnet
 	# and with any missing gaps filled in.
 	def Util.fill(ipnet,list)
-		# sort & git rid of non subnets
+		# sort & get rid of non subnets
 		subs = []
 		discard_subnets(list).each do |sub|
 			r = ipnet.rel(sub)
@@ -67,21 +67,14 @@ module NetAddr
 				filled = backfill(subs[0],base)
 			end
 			
-			# fill gaps
-			sib = ipnet.next_sib()
-			ceil = NetAddr::F32
-			if (sib != nil)
-				ceil = sib.network.addr
-			end
-			
+			# fill gaps between subnets
 			0.upto(subs.length-1) do |i|
 				sub = subs[i]
-				filled.push(sub)
-				limit = ceil
 				if (i+1 < subs.length)
-					limit = subs[i+1].network.addr
+					filled.concat( fwdfill(sub,ipnet,subs[i+1]) )
+				else
+					filled.concat( fwdfill(sub,ipnet,nil) )
 				end
-				filled.concat( fwdfill(sub,limit) )
 			end
 		end
 		return filled
@@ -131,18 +124,80 @@ module NetAddr
 		return filtered
 	end
 	
-	# fwdfill returns subnets between given IPv4Net/IPv6Nett and the limit address.
-	# limit should be > ipnet. will create subnets up to limit.
-	def Util.fwdfill(ipnet,limit)
-		nets = []
+	# fwdfill returns subnets between given IPv4Net/IPv6Nett and the limit address. limit should be > ipnet.
+	def Util.fwdfill(ipnet,supernet,limit)
+		nets = [ipnet]
 		cur = ipnet
-		while true do
-			net = cur.next
-			if (net == nil || net.network.addr >= limit)
-				break
+		if (limit != nil) # if limit, then fill gaps between net and limit
+			while true do
+				nextSub = cur.next()
+				# ensure we've not exceed the total address space
+				if (nextSub == nil)
+					break
+				end
+				# ensure we've not exceeded the address space of supernet
+				if (supernet.rel(nextSub) == nil)
+					break
+				end
+				# ensure we've not hit limit
+				if (nextSub.network.addr == limit.network.addr)
+					break
+				end
+				
+				# check relationship to limit
+				if (nextSub.rel(limit) != nil) # if related, then nextSub must be a supernet of limit. we need to shrink it.
+					prefixLen = nextSub.netmask.prefix_len
+					while true do
+						prefixLen += 1
+						if (nextSub.kind_of?(IPv4Net))
+							nextSub = IPv4Net.new(nextSub.network, Mask32.new(prefixLen))
+						else
+							nextSub = IPv6Net.new(nextSub.network, Mask128.new(prefixLen))
+						end
+						if (nextSub.rel(limit) == nil) # stop when we no longer overlap with limit
+							break
+						end
+					end
+				else # otherwise, if unrelated then grow until we hit the limit
+					prefixLen = nextSub.netmask.prefix_len
+					mask = nextSub.netmask.mask
+					while true do
+						prefixLen -= 1
+						if (prefixLen == supernet.netmask.prefix_len) # break if we've hit the supernet boundary
+							break
+						end
+						mask = mask << 1
+						if (nextSub.network.addr|mask != mask) # break when bit boundary crossed (there are '1' bits in the host portion)
+							break
+						end
+						if (nextSub.kind_of?(IPv4Net))
+							grown = IPv4Net.new(nextSub.network, Mask32.new(prefixLen))
+						else
+							grown = IPv6Net.new(nextSub.network, Mask128.new(prefixLen))
+						end
+						if (grown.rel(limit) != nil) # if we've overlapped with limit in any way, then break
+							break
+						end
+						nextSub = grown
+					end
+				end
+				nets.push(nextSub)
+				cur = nextSub
+			end
+		else # if no limit, then get next largest sibs until we've exceeded supernet
+			while true do
+				nextSub = cur.next()
+				# ensure we've not exceed the total address space
+				if (nextSub == nil)
+					break
+				end
+				# ensure we've not exceeded the address space of supernet
+				if (supernet.rel(nextSub) == nil)
+					break
+				end
+				nets.push(nextSub)
+				cur = nextSub
 			end
-			nets.push(net)
-			cur = net
 		end
 		return nets
 	end
@@ -185,7 +240,7 @@ module NetAddr
 	# parse_IPv6 parses an IPv6 address String into an Integer
 	def Util.parse_IPv6(ip)
 	# check that only valid characters are present
-		if (ip =~ /[^0-9a-fA-F\:]/)
+		if (ip =~ /[^0-9a-fA-F\:.]/)
 			raise ValidationError, "#{ip} contains invalid characters."
 		end
 		
@@ -193,6 +248,16 @@ module NetAddr
 		if (ip == "::")
 			return 0 # zero address
 		end
+		ipv4Int = nil
+		if (ip.include?(".")) # check for ipv4 embedded addresses
+			words = ip.split(":")
+			begin
+				ipv4Int = Util.parse_IPv4(words.last)
+			rescue
+				raise ValidationError, "IPv4-embedded IPv6 address is invalid."
+			end
+			ip = ip.sub(words.last,"0:0") # temporarily remove the ipv4 portion
+		end
 		words = []
 		if (ip.include?("::")) # short format
 			if (ip =~ /:{3,}/) # make sure only i dont have ":::"
@@ -228,7 +293,6 @@ module NetAddr
 				raise ValidationError, "#{ip} is too short."
 			end
 		end
-		
 		ipInt = 0
 		i = 8
 		words.each do |word|
@@ -236,7 +300,9 @@ module NetAddr
 			word = word.to_i(16) << (16*i)
 			ipInt = ipInt | word
 		end
-		
+		if ipv4Int # re-add ipv4 portion if present
+			ipInt = ipInt | ipv4Int
+		end
 		return ipInt
 	end
 		

data/test/ipv4net_test.rb

@@ -52,6 +52,7 @@ class TestIPv4Net < Test::Unit::TestCase
 	end
 
 	def test_fill
+		# filter supernet. remove subnets of subnets. basic fwd fill.
 		parent = NetAddr::IPv4Net.parse("10.0.0.0/24")
 		nets = []
 		["10.0.0.0/24", "10.0.0.0/8", "10.0.0.8/30", "10.0.0.16/30", "10.0.0.16/28"].each do |net|
@@ -64,6 +65,7 @@ class TestIPv4Net < Test::Unit::TestCase
 			i += 1
 		end
 		
+		# basic backfill
 		parent = NetAddr::IPv4Net.parse("128.0.0.0/1")
 		nets = []
 		["192.0.0.0/2"].each do |net|
@@ -76,6 +78,7 @@ class TestIPv4Net < Test::Unit::TestCase
 			i += 1
 		end
 		
+		# basic fwd fill with non-contiguous subnets
 		parent = NetAddr::IPv4Net.parse("1.0.0.0/25")
 		nets = []
 		["1.0.0.0/30", "1.0.0.64/26"].each do |net|
@@ -87,6 +90,32 @@ class TestIPv4Net < Test::Unit::TestCase
 			assert_equal(expect[i],net.to_s)
 			i += 1
 		end
+    
+		# basic backfill. complex fwd fill that uses 'shrink' of the proposed 1.0.16.0/21 subnet
+    parent = NetAddr::IPv4Net.parse("1.0.0.0/19")
+		nets = []
+		["1.0.8.0/21", "1.0.20.0/24"].each do |net|
+			nets.push(NetAddr::IPv4Net.parse(net))
+		end
+		expect = ["1.0.0.0/21","1.0.8.0/21","1.0.16.0/22","1.0.20.0/24","1.0.21.0/24","1.0.22.0/23","1.0.24.0/21"]
+		i = 0
+		parent.fill(nets).each do |net|
+			assert_equal(expect[i],net.to_s)
+			i += 1
+		end
+		
+		# list contains the supernet
+		parent = NetAddr::IPv4Net.parse("1.0.0.0/19")
+		nets = []
+		["1.0.0.0/19"].each do |net|
+			nets.push(NetAddr::IPv4Net.parse(net))
+		end
+		expect = []
+		i = 0
+		parent.fill(nets).each do |net|
+			assert_equal(expect[i],net.to_s)
+			i += 1
+		end
 	end
 	
 	def test_len

data/test/ipv6_test.rb

@@ -39,6 +39,18 @@ class TestIPv6 < Test::Unit::TestCase
 		assert_equal(0x00000001000200030004000500060007, NetAddr::IPv6.parse("::1:2:3:4:5:6:7").addr)
 		assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("fec0") }
 		assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("fec0:::1") }
+    
+    assert_equal(0x0064ff9b0000000000000000c0000221, NetAddr::IPv6.parse("64:ff9b::192.0.2.33").addr)
+    assert_equal(0x0064ff9b0000000000000000c0000221, NetAddr::IPv6.parse("64:ff9b::0:192.0.2.33").addr)
+    assert_equal(0x0064ff9b0000000000000000c0000221, NetAddr::IPv6.parse("64:ff9b::0:0:192.0.2.33").addr)
+    assert_equal(0x0064ff9b0000000000000000c0000221, NetAddr::IPv6.parse("64:ff9b::0:0:0:192.0.2.33").addr)
+    assert_equal(0x0064ff9b0000000000000000c0000221, NetAddr::IPv6.parse("64:ff9b::0:0:0:0:192.0.2.33").addr)
+    assert_equal(0x0064ff9b0000000000000000c0000221, NetAddr::IPv6.parse("64:ff9b:0:0:0:0:192.0.2.33").addr)
+    assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("64:ff9b::192.0.2") }
+    assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("64:ff9b::192.0.2.33.0") }
+    assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("64:ff9b::192.0.256.33") }
+    assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("64:ff9b:0:0:0:0:0:192.0.2.33") }
+    assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("64:ff9b::0:0:0:0:0:192.0.2.33") }
 	end
 	
 	def test_cmp
@@ -51,6 +63,32 @@ class TestIPv6 < Test::Unit::TestCase
 		assert_equal(0, ip.cmp(ip4))
 	end
 	
+	def test_ipv4
+		ipv6 = NetAddr::IPv6.parse("64:ff9b::192.0.2.33")
+		ipv4 = ipv6.ipv4()
+		assert_equal("192.0.2.33", ipv4.to_s)
+		
+		ipv6 = NetAddr::IPv6.parse("2001:db8:c000:221::")
+		ipv4 = ipv6.ipv4(32)
+		assert_equal("192.0.2.33", ipv4.to_s)
+		
+		ipv6 = NetAddr::IPv6.parse("2001:db8:1c0:2:21::")
+		ipv4 = ipv6.ipv4(40)
+		assert_equal("192.0.2.33", ipv4.to_s)
+		
+		ipv6 = NetAddr::IPv6.parse("2001:db8:122:c000:2:2100::")
+		ipv4 = ipv6.ipv4(48)
+		assert_equal("192.0.2.33", ipv4.to_s)
+		
+		ipv6 = NetAddr::IPv6.parse("2001:db8:122:3c0:0:221::")
+		ipv4 = ipv6.ipv4(56)
+		assert_equal("192.0.2.33", ipv4.to_s)
+		
+		ipv6 = NetAddr::IPv6.parse("2001:db8:122:344:c0:2:2100::")
+		ipv4 = ipv6.ipv4(64)
+		assert_equal("192.0.2.33", ipv4.to_s)
+	end
+	
 	def test_long
 		assert_equal("0000:0000:0000:0000:0000:0000:0000:0000", NetAddr::IPv6.parse("::").long)
 		assert_equal("fe80:0000:0000:0000:0000:0000:0000:0001", NetAddr::IPv6.parse("fe80::1").long)
@@ -83,6 +121,7 @@ class TestIPv6 < Test::Unit::TestCase
 		assert_equal("::1:0:0", NetAddr::IPv6.parse("0:0:0:0:0:1:0:0").to_s)
 		assert_equal("::1:0", NetAddr::IPv6.parse(":0:0:0:0:0:1:0").to_s)
 		assert_equal("::1", NetAddr::IPv6.parse("0:0:0:0:0:0:0:1").to_s)
+		assert_equal("1:0:1:1:1:1:1:1", NetAddr::IPv6.parse("1:0:1:1:1:1:1:1").to_s) # see RFC 5952 section 4.2.2
 		
 		assert_equal("1::1", NetAddr::IPv6.parse("1:0:0:0:0:0:0:1").to_s)
 		assert_equal("1:1::1", NetAddr::IPv6.parse("1:1:0:0:0:0:0:1").to_s)

data/test/ipv6net_test.rb

@@ -48,18 +48,33 @@ class TestIPv6Net < Test::Unit::TestCase
 	end
 
 	def test_fill
+		# filter supernet. remove subnets of subnets. basic fwd fill.
 		parent = NetAddr::IPv6Net.parse("ff00::/8")
 		nets = []
-		["ff08::/14", "fe00::/7", "ff20::/11", "ff20::/12"].each do |net|
+		["ff00::/8", "ff00::/9", "ff08::/14", "fe00::/7", "ff20::/11", "ff20::/12"].each do |net|
 			nets.push(NetAddr::IPv6Net.parse(net))
 		end
-		expect = ["ff00::/13", "ff08::/14", "ff0c::/14", "ff10::/12", "ff20::/11", "ff40::/10", "ff80::/9"]
+		expect = ["ff00::/9", "ff80::/9"]
 		i = 0
 		parent.fill(nets).each do |net|
 			assert_equal(expect[i],net.to_s)
 			i += 1
 		end
 		
+		# basic backfill
+		parent = NetAddr::IPv6Net.parse("8000::/1")
+		nets = []
+		["c000::/2"].each do |net|
+			nets.push(NetAddr::IPv6Net.parse(net))
+		end
+		expect = ["8000::/2","c000::/2"]
+		i = 0
+		parent.fill(nets).each do |net|
+			assert_equal(expect[i],net.to_s)
+			i += 1
+		end
+		
+		# basic fwd fill with non-contiguous subnets
 		parent = NetAddr::IPv6Net.parse("ff00::/121")
 		nets = []
 		["ff00::/126", "ff00::/120"].each do |net|
@@ -71,6 +86,33 @@ class TestIPv6Net < Test::Unit::TestCase
 			assert_equal(expect[i],net.to_s)
 			i += 1
 		end
+		
+		# basic backfill. complex fwd fill that uses 'shrink' of the proposed ffff:ffff:ffff:fff8::/62 subnet. designed to cross the /64 bit boundary.
+		parent = NetAddr::IPv6Net.parse("fff:ffff:ffff:fff0::/60")
+		nets = []
+		["ffff:ffff:ffff:fff4::/62", "ffff:ffff:ffff:fffb::/65"].each do |net|
+			nets.push(NetAddr::IPv6Net.parse(net))
+		end
+		expect = ["ffff:ffff:ffff:fff0::/62", "ffff:ffff:ffff:fff4::/62", "ffff:ffff:ffff:fff8::/63", "ffff:ffff:ffff:fffa::/64", "ffff:ffff:ffff:fffb::/65",
+			"ffff:ffff:ffff:fffb:8000::/65", "ffff:ffff:ffff:fffc::/62"]
+		i = 0
+		parent.fill(nets).each do |net|
+			assert_equal(expect[i],net.to_s)
+			i += 1
+		end
+		
+		# list contains the supernet
+		parent = NetAddr::IPv6Net.parse("ffff::/16")
+		nets = []
+		["ffff::/16"].each do |net|
+			nets.push(NetAddr::IPv6Net.parse(net))
+		end
+		expect = []
+		i = 0
+		parent.fill(nets).each do |net|
+			assert_equal(expect[i],net.to_s)
+			i += 1
+		end
 	end
 	
 	def test_next

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: netaddr
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.0.5
 platform: ruby
 authors:
 - Dustin Spinhirne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-03 00:00:00.000000000 Z
+date: 2021-10-07 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: 
@@ -60,8 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A Ruby library for performing calculations on IPv4 and IPv6 subnets.