netaddr 1.5.3 → 2.0.1

data/lib/mask32.rb

@@ -0,0 +1,99 @@
+module NetAddr
+	
+	#Mask32 represents a 32-bit netmask. 
+	class Mask32
+		# mask is the Integer representation of this netmask
+		attr_reader :mask
+		
+		# prefix_len is the Integer prefix length of this netmask
+		attr_reader :prefix_len
+		
+		# Create a Mask32 from an Integer prefix length. Valid values are 0-32.
+		# Throws ValidationError on error.
+		def initialize(prefix_len)
+			if (!prefix_len.kind_of?(Integer))
+				raise ValidationError, "Expected an Integer for 'prefix_len' but got a #{prefix_len.class}."
+			elsif ( (prefix_len < 0) || (prefix_len > 32) )
+				raise ValidationError, "#{prefix_len} must be in the range of 0-32."
+			end
+			@prefix_len = prefix_len
+			@mask = NetAddr::F32 ^ (NetAddr::F32 >> @prefix_len)
+		end
+		
+		# parse will create an Mask32 from its string representation.
+		# arguments:
+		#	* mask - String representing a netmask (ie. "/24" or "255.255.255.0").
+		#
+		#	Throws ValidationError on error.
+		def Mask32.parse(mask)
+			mask.strip!
+			if (mask.start_with?("/")) # cidr format
+				return Mask32.new(mask[1..-1].to_i) # remove "/"
+			elsif (!mask.include?("."))
+				return Mask32.new(mask.to_i)
+			end
+			
+			# for extended netmask
+			# determine length of netmask by cycling through bit by bit and looking
+			# for the first '1' bit, tracking the length as we go. we also want to verify
+			# that the mask is valid (ie. not something like 255.254.255.0). we do this
+			# by creating a hostmask which covers the '0' bits of the mask. once we have
+			# separated the net vs host mask we xor them together. the result should be that
+			# all bits are now '1'. if not then we know we have an invalid netmask.
+			maskI = Util.parse_IPv4(mask)
+			prefix = 32
+			hostmask = 1
+			i = maskI 
+			32.downto(1) do
+				if (i&1 == 1)
+					hostmask = hostmask >> 1
+					if (maskI ^hostmask != NetAddr::F32)
+						raise ValidationError, "#{mask} is invalid. It contains '1' bits in its host portion."
+					end
+					break
+				end
+				hostmask = (hostmask << 1) | 1
+				i = i>>1
+				prefix -= 1
+			end
+			return Mask32.new(prefix)
+			
+		end
+		
+		# extended returns the Mask32 in extended format (eg. x.x.x.x)
+		def extended()
+			Util.intToMask32(@mask)
+		end
+		
+		#cmp compares equality with another Mask32. Return:
+		#* 1 if this Mask128 is larger in capacity
+		#* 0 if the two are equal
+		#* -1 if this Mask128 is smaller in capacity
+		def cmp(other)
+			if (!other.kind_of?(Mask32))
+				raise ArgumentError, "Expected an Mask32 object for 'other' but got a #{other.class}."
+			end
+			if (self.prefix_len < other.prefix_len)
+				return 1
+			elsif (self.prefix_len > other.prefix_len)
+				return -1
+			end
+			return 0
+		end
+		
+		#len returns the number of IP addresses in this network. It will always return 0 for /0 networks.
+		def len()
+			if (self.prefix_len == 0)
+				return 0
+			end
+			return (self.mask ^ NetAddr::F32) + 1 # bit flip the netmask and add 1
+		end
+		
+		# to_s returns the Mask32 as a String
+		def to_s()
+			return "/#{@prefix_len}"
+		end
+		
+	end # end class Mask32
+	
+end # end module

data/lib/netaddr.rb

@@ -1,24 +1,108 @@
-require 'time'
-require 'digest/sha1'
-require File.join(File.dirname(__FILE__), 'validation_shortcuts.rb')
-require File.join(File.dirname(__FILE__), 'ip_math.rb')
-require File.join(File.dirname(__FILE__), 'cidr_shortcuts.rb')
-require File.join(File.dirname(__FILE__), 'methods.rb')
-require File.join(File.dirname(__FILE__), 'cidr.rb')
-require File.join(File.dirname(__FILE__), 'tree.rb')
-require File.join(File.dirname(__FILE__), 'eui.rb')
+require_relative "eui48.rb"
+require_relative "eui64.rb"
+require_relative "ipv4.rb"
+require_relative "ipv4net.rb"
+require_relative "ipv6.rb"
+require_relative "ipv6net.rb"
+require_relative "mask32.rb"
+require_relative "mask128.rb"
+require_relative "util.rb"
 
 module NetAddr
+	# Constants
+	
+	# 32 bits worth of '1'
+	F32 = 2**32-1
+	
+	# 128 bits worth of '1'
+	F128 = 2**128-1
+	
 
-  class BoundaryError < StandardError #:nodoc:
+	# ValidationError is thrown when a method fails a validation test.
+  class ValidationError < StandardError
   end
-
-  class ValidationError < StandardError #:nodoc:
-  end
-
-  class VersionError < StandardError #:nodoc:
-  end
-
-end # module NetAddr
-
-__END__
+	
+	# ipv4_prefix_len returns the prefix length needed to hold the number of IP addresses specified by "size".
+	def ipv4_prefix_len(size)
+		prefix_len = 32
+		32.downto(0) do |i|
+			hostbits = 32 - prefix_len
+			max = 1 << hostbits
+			if (size <= max)
+				break
+			end
+			prefix_len -= 1
+		end
+		return prefix_len
+	end
+	module_function :ipv4_prefix_len
+	
+	# sort_IPv4 sorts a list of IPv4 objects in ascending order.
+	# It will return a new list with any non IPv4 objects removed.
+	def sort_IPv4(list)
+		if ( !list.kind_of?(Array) )
+			raise ArgumentError, "Expected an Array for 'list' but got a #{list.class}."
+		end
+		filtered = Util.filter_IPv4(list)
+		return Util.quick_sort(filtered)
+	end
+	module_function :sort_IPv4
+	
+	# sort_IPv6 sorts a list of IPv6 objects in ascending order.
+	# It will return a new list with any non IPv6 objects removed.
+	def sort_IPv6(list)
+		if ( !list.kind_of?(Array) )
+			raise ArgumentError, "Expected an Array for 'list' but got a #{list.class}."
+		end
+		filtered = Util.filter_IPv6(list)
+		return Util.quick_sort(filtered)
+	end
+	module_function :sort_IPv6
+	
+	# sort_IPv4Net sorts a list of IPv4Net objects in ascending order.
+	# It will return a new list with any non IPv4Net objects removed.
+	def sort_IPv4Net(list)
+		if ( !list.kind_of?(Array) )
+			raise ArgumentError, "Expected an Array for 'list' but got a #{list.class}."
+		end
+		filtered = Util.filter_IPv4Net(list)
+		return Util.quick_sort(filtered)
+	end
+	module_function :sort_IPv4Net
+	
+	# sort_IPv6Net sorts a list of IPv6Net objects in ascending order.
+	# It will return a new list with any non IPv6Net objects removed.
+	def sort_IPv6Net(list)
+		if ( !list.kind_of?(Array) )
+			raise ArgumentError, "Expected an Array for 'list' but got a #{list.class}."
+		end
+		filtered = Util.filter_IPv6Net(list)
+		return Util.quick_sort(filtered)
+	end
+	module_function :sort_IPv6Net
+	
+	# summ_IPv4Net summarizes a list of IPv4Net objects as much as possible.
+	# It will return a new list with any non IPv4Net objects removed.
+	def summ_IPv4Net(list)
+		list = Util.filter_IPv4Net(list)
+		if (list.length>1)
+			list = Util.discard_subnets(list)
+			return Util.summ_peers(list)
+		end
+		return [].concat(list)
+	end
+	module_function :summ_IPv4Net
+	
+	# summ_IPv6Net summarizes a list of IPv6Net objects as much as possible.
+	# It will return a new list with any non IPv6Net objects removed.
+	def summ_IPv6Net(list)
+		list = Util.filter_IPv6Net(list)
+		if (list.length>1)
+			list = Util.discard_subnets(list)
+			return Util.summ_peers(list)
+		end
+		return [].concat(list)
+	end
+	module_function :summ_IPv6Net
+	
+end # end module

data/lib/util.rb

@@ -0,0 +1,310 @@
+module NetAddr
+	
+	# Contains various internal util functions
+	class Util
+	private
+	
+	# backfill generates subnets between given IPv4Net/IPv6Net and the limit address.
+	# limit should be < ipnet. will create subnets up to and including limit.
+	def Util.backfill(ipnet,limit)
+		nets = []
+		cur = ipnet
+		while true do
+			net = cur.prev
+			if (net == nil || net.network.addr < limit)
+				break
+			end
+			nets.unshift(net)
+			cur = net
+		end
+		return nets
+	end
+	
+	
+	# discard_subnets returns a copy of the IPv4NetList with any entries which are subnets of other entries removed.
+	def Util.discard_subnets(list)
+		unrelated = []
+		supernets = []
+		last = list[list.length-1]
+		list.each do |net|
+			rel = last.rel(net)
+			if (!rel)
+				unrelated.push(net)
+			elsif (rel == -1) # last is subnet of net
+				supernets.push(net)
+			end
+		end
+		
+		cleaned = []
+		if (supernets.length > 0)
+			cleaned = discard_subnets(supernets)
+		else
+			cleaned.push(last)
+		end
+		
+		if (unrelated.length > 0)
+			cleaned.concat( discard_subnets(unrelated) )
+		end
+		return cleaned
+	end
+	
+	# 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
+		subs = []
+		discard_subnets(list).each do |sub|
+			r = ipnet.rel(sub)
+			if (r == 1)
+				subs.push(sub)
+			end
+		end
+		subs = quick_sort(subs)
+		
+		filled = []
+		if (subs.length > 0)
+			# bottom fill if base missing
+			base = ipnet.network.addr
+			if (subs[0].network.addr != base)
+				filled = backfill(subs[0],base)
+			end
+			
+			# fill gaps
+			sib = ipnet.next_sib()
+			ceil = NetAddr::F32
+			if (sib != nil)
+				ceil = sib.network.addr
+			end
+			
+			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
+				end
+				filled.concat( fwdfill(sub,limit) )
+			end
+		end
+		return filled
+	end
+	
+	# filter_IPv4 returns a copy of list with only IPv4 objects
+	def Util.filter_IPv4(list)
+		filtered = []
+		list.each do |ip|
+			if (ip.kind_of?(IPv4))
+				filtered.push(ip)
+			end
+		end
+		return filtered
+	end
+	
+	# filter_IPv4Net returns a copy of list with only IPv4Net objects
+	def Util.filter_IPv4Net(list)
+		filtered = []
+		list.each do |ip|
+			if (ip.kind_of?(IPv4Net))
+				filtered.push(ip)
+			end
+		end
+		return filtered
+	end
+	
+	# filter_IPv6 returns a copy of list with only IPv6 objects
+	def Util.filter_IPv6(list)
+		filtered = []
+		list.each do |ip|
+			if (ip.kind_of?(IPv6))
+				filtered.push(ip)
+			end
+		end
+		return filtered
+	end
+	
+	# filter_IPv6Net returns a copy of list with only IPv4Net objects
+	def Util.filter_IPv6Net(list)
+		filtered = []
+		list.each do |ip|
+			if (ip.kind_of?(IPv6Net))
+				filtered.push(ip)
+			end
+		end
+		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 = []
+		cur = ipnet
+		while true do
+			net = cur.next
+			if (net == nil || net.network.addr >= limit)
+				break
+			end
+			nets.push(net)
+			cur = net
+		end
+		return nets
+	end
+	
+	# int_to_IPv4 converts an Integer into an IPv4 address String
+	def Util.int_to_IPv4(i)
+		octets = []
+		3.downto(0) do |x|
+			octet = (i >> 8*x) & 0xFF 
+			octets.push(octet.to_s)
+		end
+		return octets.join('.')
+	end
+	
+	# parse_IPv4 parses an IPv4 address String into an Integer
+	def Util.parse_IPv4(ip)
+	# check that only valid characters are present
+		if (ip =~ /[^0-9\.]/)
+			raise ValidationError, "#{ip} contains invalid characters."
+		end
+		
+		ip.strip!
+		octets = ip.split('.')
+		if (octets.length != 4)
+			raise ValidationError, "IPv4 requires (4) octets."
+		end
+
+		ipInt = 0
+		i = 4
+		octets.each do |octet|
+			octetI = octet.to_i()
+			if ( (octetI < 0) || (octetI >= 256) )
+				raise ValidationError, "#{ip} is out of bounds for IPv4."
+			end
+			i -= 1 
+			ipInt = ipInt | (octetI << 8*i)
+		end
+		return ipInt
+	end
+	
+	# 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\:]/)
+			raise ValidationError, "#{ip} contains invalid characters."
+		end
+		
+		ip.strip!
+		if (ip == "::")
+			return 0 # zero address
+		end
+		words = []
+		if (ip.include?("::")) # short format
+			if (ip =~ /:{3,}/) # make sure only i dont have ":::"
+				raise ValidationError, "#{ip} contains invalid field separator."
+			end
+			if (ip.scan(/::/).length != 1)
+				raise ValidationError, "#{ip} contains multiple '::' sequences."
+			end
+			
+			halves = ip.split("::")
+			if (halves[0] == nil) # cases such as ::1
+				halves[0] = "0"
+			end
+			if (halves[1] == nil) # cases such as 1::
+				halves[1] = "0"
+			end
+			upHalf = halves[0].split(":")
+			loHalf = halves[1].split(":")
+			numWords = upHalf.length + loHalf.length
+			if (numWords > 8)
+				raise ValidationError, "#{ip} is too long."
+			end
+			words = upHalf
+			(8-numWords).downto(1) do |i|
+				words.push("0")
+			end
+			words.concat(loHalf)
+		else
+			words = ip.split(":")
+			if (words.length > 8)
+			   raise ValidationError, "#{ip} is too long."
+			elsif (words.length < 8)
+				raise ValidationError, "#{ip} is too short."
+			end
+		end
+		
+		ipInt = 0
+		i = 8
+		words.each do |word|
+			i -= 1
+			word = word.to_i(16) << (16*i)
+			ipInt = ipInt | word
+		end
+		
+		return ipInt
+	end
+		
+	# quick_sort will return a sorted copy of the provided Array.
+	# The array must contain only objects which implement a cmp method and which are comparable to each other.
+	def Util.quick_sort(list)
+		if (list.length <= 1)
+			return [].concat(list)
+		end
+		
+		final_list = []
+		lt_list = []
+		gt_list = []
+		eq_list = []
+		pivot = list[list.length-1]
+		list.each do |ip|
+			cmp = pivot.cmp(ip)
+			if (cmp == 1)
+				lt_list.push(ip)
+			elsif (cmp == -1)
+				gt_list.push(ip)
+			else
+				eq_list.push(ip)
+			end
+		end
+		final_list.concat( quick_sort(lt_list) )
+		final_list.concat(eq_list)
+		final_list.concat( quick_sort(gt_list) )
+		return final_list
+	end
+	
+	# summ_peers returns a copy of the list with any merge-able subnets summ'd together.
+	def Util.summ_peers(list)
+		summd = quick_sort(list)
+		while true do
+			list_len = summd.length
+			last = list_len - 1
+			tmp_list = []
+			i = 0
+			while (i < list_len) do
+				net = summd[i]
+				next_net = i+1
+				if (i != last)
+					# if this net and next_net summarize then discard them & keep summary
+					new_net = net.summ(summd[next_net])
+					if (new_net) # can summ. keep summary
+						tmp_list.push(new_net)
+						i += 1 # skip next_net
+					else # cant summ. keep existing
+						tmp_list.push(net)
+					end
+				else
+					tmp_list.push(net) # keep last
+				end
+				i += 1
+			end
+			
+			# stop when list stops getting shorter
+			if (tmp_list.length == list_len)
+				break
+			end
+			summd = tmp_list
+		end
+		return summd
+	end
+	
+	end # end class
+end # end module

data/test/eui48_test.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby
+
+require_relative "../lib/netaddr.rb"
+require 'test/unit'
+
+class TestEUI48 < Test::Unit::TestCase
+	def test_new
+		eui = NetAddr::EUI48.new(0)
+		assert_equal("00-00-00-00-00-00", eui.to_s)
+		
+		assert_raise(NetAddr::ValidationError){ NetAddr::EUI48.new(2**48) }
+		assert_raise(NetAddr::ValidationError){ NetAddr::EUI48.new(-1) }
+		assert_raise(NetAddr::ValidationError){ NetAddr::EUI48.new("00-00-00-00-00-00") } # string
+	end
+	
+	def test_parse
+		assert_equal("aa-bb-cc-dd-ee-ff", NetAddr::EUI48.parse("aa-bb-cc-dd-ee-ff").to_s)
+		assert_equal("aa-bb-cc-dd-ee-ff", NetAddr::EUI48.parse("aa:bb:cc:dd:ee:ff").to_s)
+		assert_equal("aa-bb-cc-dd-ee-ff", NetAddr::EUI48.parse("aabb.ccdd.eeff").to_s)
+		assert_equal("aa-bb-cc-dd-ee-ff", NetAddr::EUI48.parse("aabbccddeeff").to_s)
+		
+		assert_raise(NetAddr::ValidationError){ NetAddr::EUI48.parse("aa-bb-cc-dd-ee-ff-00-11") }
+		assert_raise(NetAddr::ValidationError){ NetAddr::EUI48.parse("aa-bb-cc-dd-ee-gg") }
+		assert_raise(NetAddr::ValidationError){ NetAddr::EUI48.parse("aa;bb;cc;dd;ee;ff") }
+	end
+	
+	def test_to_eui64
+		assert_equal("aa-bb-cc-ff-fe-dd-ee-ff", NetAddr::EUI48.parse("aa-bb-cc-dd-ee-ff").to_eui64.to_s)
+	end
+end

data/test/eui64_test.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/ruby
+
+require_relative "../lib/netaddr.rb"
+require 'test/unit'
+
+class TestEUI64 < Test::Unit::TestCase
+	def test_new
+		eui = NetAddr::EUI64.new(0)
+		assert_equal("00-00-00-00-00-00-00-00", eui.to_s)
+		
+		assert_raise(NetAddr::ValidationError){ NetAddr::EUI64.new(2**64) }
+		assert_raise(NetAddr::ValidationError){ NetAddr::EUI64.new(-1) }
+		assert_raise(NetAddr::ValidationError){ NetAddr::EUI64.new("00-00-00-00-00-00-00-00") } # string
+	end
+	
+	def test_parse
+		assert_equal("aa-bb-cc-dd-ee-ff-00-11", NetAddr::EUI64.parse("aa-bb-cc-dd-ee-ff-00-11").to_s)
+		assert_equal("aa-bb-cc-dd-ee-ff-00-11", NetAddr::EUI64.parse("aa:bb:cc:dd:ee:ff:00:11").to_s)
+		assert_equal("aa-bb-cc-dd-ee-ff-00-11", NetAddr::EUI64.parse("aabb.ccdd.eeff.0011").to_s)
+		assert_equal("aa-bb-cc-dd-ee-ff-00-11", NetAddr::EUI64.parse("aabbccddeeff0011").to_s)
+		
+		assert_raise(NetAddr::ValidationError){ NetAddr::EUI64.parse("aa-bb-cc-dd-ee-ff-00-11-22") }
+		assert_raise(NetAddr::ValidationError){ NetAddr::EUI64.parse("aa-bb-cc-dd-ee-ff-gg") }
+		assert_raise(NetAddr::ValidationError){ NetAddr::EUI64.parse("aa;bb;cc;dd;ee;ff;00;11") }
+	end
+	
+	def test_to_ipv6
+		net = NetAddr::IPv6Net.parse("fe80::/64")
+		eui = NetAddr::EUI64.parse("aa-bb-cc-dd-ee-ff-00-11")
+		assert_equal("fe80::a8bb:ccdd:eeff:11", eui.to_ipv6(net).to_s)
+	end
+end