netaddr 1.5.3 → 2.0.6

data/lib/mask128.rb

@@ -0,0 +1,70 @@
+module NetAddr
+	
+	#Mask128 represents a 128-bit netmask. 
+	class Mask128
+		# 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 Mask128 from an Integer prefix length. Valid values are 0-128.
+		# 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 > 128) )
+				raise ValidationError, "#{prefix_len} must be in the range of 0-128."
+			end
+			@prefix_len = prefix_len
+			@mask = NetAddr::F128 ^ (NetAddr::F128 >> @prefix_len)
+		end
+		
+		# parse will create an Mask128 from its string representation.
+		# arguments:
+		# * mask - String representing an netmask (ie. "/64").
+		#
+		# Throws ValidationError on error.
+		def Mask128.parse(mask)
+			mask = mask.strip
+			if (mask.start_with?("/")) # cidr format
+				mask = mask[1..-1] # remove "/"
+			end
+			return Mask128.new(Integer(mask))
+		rescue ArgumentError
+			raise ValidationError, "#{mask} is not valid integer."
+		end
+		
+		#cmp compares equality with another Mask128. 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?(Mask128))
+				raise ArgumentError, "Expected an Mask128 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. This is only useful if you have a subnet
+		# smaller than a /64 as it will always return 0 for prefixes <= 64.
+		def len()
+			if (self.prefix_len <= 64)
+				return 0
+			end
+			return (self.mask ^ NetAddr::F128) + 1 # bit flip the netmask and add 1
+		end
+		
+		# to_s returns the Mask128 as a String
+		def to_s()
+			return "/#{@prefix_len}"
+		end
+		
+	end # end class Mask128
+	
+end # end module

data/lib/mask32.rb

@@ -0,0 +1,105 @@
+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 = mask.strip
+			if (mask.start_with?("/")) # cidr format
+				mask = mask[1..-1] # remove "/"
+			end
+
+			if (!mask.include?("."))
+				begin
+					return Mask32.new(Integer(mask))
+				rescue ArgumentError
+					raise ValidationError, "#{mask} is not valid integer."
+				end
+			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.int_to_IPv4(@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,126 @@
-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
+	
+	## parse_ip parses a string into an IPv4 or IPv6
+	def parse_ip(ip)
+		if (ip.include?(":"))
+			return IPv6.parse(ip)
+		end
+		return IPv4.parse(ip)
+	end
+	module_function :parse_ip
+	
+	## parse_net parses a string into an IPv4Net or IPv6Net
+	def parse_net(net)
+		if (net.include?(":"))
+			return IPv6Net.parse(net)
+		end
+		return IPv4Net.parse(net)
+	end
+	module_function :parse_net
+	
+	# 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,373 @@
+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)
+		keepers = []
+		last = list[list.length-1]
+		keep_last = true
+		list.each do |net|
+			rel = last.rel(net)
+			if (!rel) # keep unrelated nets
+				keepers.push(net)
+			elsif (rel == -1) # keep supernets, but do not keep last
+				keepers.push(net)
+				keep_last = false
+			end
+		end
+		
+		# recursively clean up keepers
+		if (keepers.length > 0)
+			keepers = discard_subnets(keepers)
+		end
+		if keep_last
+			keepers.unshift(last)
+		end
+		return keepers
+	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 & get 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 between subnets
+			0.upto(subs.length-1) do |i|
+				sub = subs[i]
+				if (i+1 < subs.length)
+					filled.concat( fwdfill(sub,ipnet,subs[i+1]) )
+				else
+					filled.concat( fwdfill(sub,ipnet,nil) )
+				end
+			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.
+	def Util.fwdfill(ipnet,supernet,limit)
+		nets = [ipnet]
+		cur = ipnet
+		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
+		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
+		
+		octets = ip.strip.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 = ip.strip
+		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 ":::"
+				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
+		if ipv4Int # re-add ipv4 portion if present
+			ipInt = ipInt | ipv4Int
+		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