netaddr 1.5.3 → 2.0.6

data/lib/ipv4net.rb

@@ -0,0 +1,262 @@
+module NetAddr
+	
+	#IPv4Net represents an IPv4 network. 
+	class IPv4Net
+		
+		#arguments:
+		#* ip - an IPv4 object
+		#* m32 - a Mask32 object. will default to a /32 if nil
+		def initialize(ip,m32)
+			if (!ip.kind_of?(IPv4))
+				raise ArgumentError, "Expected an IPv4 object for 'ip' but got a #{ip.class}."
+			elsif (m32 != nil && !m32.kind_of?(Mask32))
+				raise ArgumentError, "Expected a Mask32 object for 'm32' but got a #{m32.class}."
+			end
+			
+			if (m32 == nil)
+				m32 = Mask32.new(32)
+			end
+			@m32 = m32
+			@base = IPv4.new(ip.addr & m32.mask)
+		end
+		
+		# parse will create an IPv4Net from its string representation. Will default to a /32 netmask if not specified.
+		# Throws ValidationError on error.
+		def IPv4Net.parse(net)
+			net = net.strip
+			m32 = nil
+			if (net.include?("/")) # cidr format
+				addr,mask = net.split("/")
+				m32 = Mask32.parse(mask)
+			elsif (net.include?(" ") ) # extended format
+				addr,mask = net.split(' ')
+				m32 = Mask32.parse(mask)
+			else
+				addr = net
+			end
+			ip = IPv4.parse(addr)
+			return IPv4Net.new(ip,m32)
+		end
+
+		# extended returns the IPv4Net in extended format (eg. x.x.x.x y.y.y.y)
+		def extended()
+			return @base.to_s + " " + Util.int_to_IPv4(@m32.mask)
+		end
+		
+		# cmp compares equality with another IPv4Net. Return:
+		# * 1 if this IPv4Net is numerically greater
+		# * 0 if the two are equal
+		# * -1 if this IPv4Net is numerically less
+		#
+		# The comparison is initially performed on using the cmp() method of the network address, however, in cases where the network
+		# addresses are identical then the netmasks will be compared with the cmp() method of the netmask. 
+		def cmp(other)
+			if (!other.kind_of?(IPv4Net))
+				raise ArgumentError, "Expected an IPv4Net object for 'other' but got a #{other.class}."
+			end
+			cmp = self.network.cmp(other.network)
+			if (cmp != 0)
+				return cmp
+			end
+			return self.netmask.cmp(other.netmask)
+		end
+		
+		#contains returns true if the IPv4Net contains the IPv4
+		def contains(ip)
+			if (!ip.kind_of?(IPv4))
+				raise ArgumentError, "Expected an IPv4 object for 'ip' but got a #{ip.class}."
+			end
+			if (@base.addr == ip.addr & @m32.mask)
+				return true
+			end
+			return false
+		end
+		
+		# fill returns a copy of the given Array, stripped of any networks which are not subnets of this IPv4Net
+		# and with any missing gaps filled in.
+		def fill(list)
+			list = Util.filter_IPv4Net(list)
+			return Util.fill(self,list)
+		end
+		
+		# netmask returns the Mask32 object representing the netmask for this network
+		def netmask()
+			@m32
+		end
+			
+		# network returns the IPv4 object representing the network address
+		def network()
+			@base
+		end
+		
+		#len returns the number of IP addresses in this network. It will return 0 for /0 networks.
+		def len()
+			return self.netmask.len
+		end
+		
+		# next returns the next largest consecutive IP network or nil if the end of the address space is reached.
+		def next()
+			net = self.nth_next_sib(1)
+			if (!net)
+				return nil
+			end
+			return net.grow
+		end
+		
+		# next_sib returns the network immediately following this one or nil if the end of the address space is reached.
+		def next_sib()
+			self.nth_next_sib(1)
+		end
+		
+		# nth returns the IPv4 at the given index.
+		# The size of the network may be determined with the len() method.
+		# If the range is exceeded then return nil.
+		def nth(index)
+			if (!index.kind_of?(Integer))
+				raise ArgumentError, "Expected an Integer for 'index' but got a #{index.class}."
+			elsif (index >= self.len)
+				return nil
+			end
+			return IPv4.new(self.network.addr + index)
+		end
+		
+		# nth_subnet returns the subnet IPv4Net at the given index.
+		# The number of subnets may be determined with the subnet_count() method.
+		# If the range is exceeded  or an invalid prefix_len is provided then return nil.
+		def nth_subnet(prefix_len,index)
+			count = self.subnet_count(prefix_len)
+			if (count == 0 || index >= count)
+				return nil
+			end
+			sub0 = IPv4Net.new(self.network, Mask32.new(prefix_len))
+			return sub0.nth_next_sib(index)
+		end
+		
+		# prev returns the previous largest consecutive IP network or nil if this is 0.0.0.0.
+		def prev()
+			net = self.grow
+			return net.prev_sib
+		end
+		
+		# prev_sib returns the network immediately preceding this one or nil if this network is 0.0.0.0.
+		def prev_sib()
+			if (self.network.addr == 0)
+				return nil
+			end
+			
+			shift = 32 - self.netmask.prefix_len
+			addr = ((self.network.addr>>shift) - 1) << shift
+			return IPv4Net.new(IPv4.new(addr), self.netmask)
+		end
+		
+		# rel determines the relationship to another IPv4Net. Returns:
+		# * 1 if this IPv4Net is the supernet of other
+		# * 0 if the two are equal
+		# * -1 if this IPv4Net is a subnet of other
+		# * nil if the networks are unrelated
+		def rel(other)
+			if (!other.kind_of?(IPv4Net))
+				raise ArgumentError, "Expected an IPv4Net object for 'other' but got a #{other.class}."
+			end
+			
+			# when networks are equal then we can look exlusively at the netmask
+			if (self.network.addr == other.network.addr)
+				return self.netmask.cmp(other.netmask)
+			end
+			
+			# when networks are not equal we can use hostmask to test if they are
+			# related and which is the supernet vs the subnet
+			hostmask = self.netmask.mask ^ NetAddr::F32
+			otherHostmask = other.netmask.mask ^ NetAddr::F32
+			if (self.network.addr|hostmask == other.network.addr|hostmask)
+				return 1
+			elsif (self.network.addr|otherHostmask == other.network.addr|otherHostmask)
+				return -1
+			end
+			return nil
+		end
+		
+		# resize returns a copy of the network with an adjusted netmask.
+		# Throws ValidationError on invalid prefix_len.
+		def resize(prefix_len)
+			m32 = Mask32.new(prefix_len)
+			return IPv4Net.new(self.network,m32)
+		end
+		
+		# subnet_count returns the number a subnets of a given prefix length that this IPv4Net contains.
+		# It will return 0 for invalid requests (ie. bad prefix or prefix is shorter than that of this network).
+		# It will also return 0 if the result exceeds the capacity of a 32-bit integer (ie. if you want the # of /32 a /0 will hold)
+		def subnet_count(prefix_len)
+			if (prefix_len <= self.netmask.prefix_len || prefix_len > 32 || prefix_len - self.netmask.prefix_len >= 32)
+				return 0
+			end
+			return 1 << (prefix_len - self.netmask.prefix_len)
+		end
+		
+		# summ creates a summary address from this IPv4Net and another.
+		# It returns nil if the two networks are incapable of being summarized.
+		def summ(other)
+			if (!other.kind_of?(IPv4Net))
+				raise ArgumentError, "Expected an IPv4Net object for 'other' but got a #{other.class}."
+			end
+			
+			# netmasks must be identical
+			if (self.netmask.prefix_len != other.netmask.prefix_len)
+				return nil
+			end
+			
+			# merge-able networks will be identical if you right shift them by the number of bits in the hostmask + 1
+			shift = 32 - self.netmask.prefix_len + 1
+			addr = self.network.addr >> shift
+			otherAddr = other.network.addr >> shift
+			if (addr != otherAddr)
+				return nil
+			end
+			return self.resize(self.netmask.prefix_len - 1)
+		end
+		
+		# to_s returns the IPv4Net as a String
+		def to_s()
+			return @base.to_s + @m32.to_s
+		end
+		
+		# version returns "4" for IPv4
+		def version()
+			return 4
+		end
+		
+		
+		protected
+
+		# grow decreases the prefix length as much as possible without crossing a bit boundary.
+		def grow()
+			addr = self.network.addr
+			mask = self.netmask.mask
+			prefix_len = self.netmask.prefix_len
+			self.netmask.prefix_len.downto(0) do
+				mask = (mask << 1) & NetAddr::F32
+				if addr|mask != mask || prefix_len == 0 # // bit boundary crossed when there are '1' bits in the host portion
+					break
+				end
+				prefix_len -= 1
+			end
+			return IPv4Net.new(IPv4.new(addr),Mask32.new(prefix_len))
+		end
+		
+		# nth_next_sib returns the nth next sibling network or nil if address space exceeded.
+		def nth_next_sib(nth)
+			if (nth < 0)
+				return nil
+			end
+			
+			shift = 32 - self.netmask.prefix_len
+			addr = ((self.network.addr>>shift) + nth) << shift
+			if addr > NetAddr::F32
+				return nil
+			end
+			return IPv4Net.new(IPv4.new(addr), self.netmask)
+		end
+		
+	end # end class IPv4Net
+	
+end # end module

data/lib/ipv6.rb

@@ -0,0 +1,146 @@
+module NetAddr
+	
+	#IPv6 represents a single IPv6 address. 
+	class IPv6
+		# addr is the Integer representation of this IP address
+		attr_reader :addr
+		
+		#Create an IPv6 from an Integer. Must be between 0 and 2**128-1.
+		#Throws ValidationError on error.
+		def initialize(i)
+			if (!i.kind_of?(Integer))
+				raise ValidationError, "Expected an Integer for 'i' but got a #{i.class}."
+			elsif ( (i < 0) || (i > NetAddr::F128) )
+				raise ValidationError, "#{i} is out of bounds for IPv6."
+			end
+			@addr = i
+		end
+		
+		# parse will create an IPv6 from its string representation (ie. "1::").
+		# Throws ValidationError on error.
+		def IPv6.parse(ip)
+			ip = ip.strip
+			i = Util.parse_IPv6(ip)
+			return IPv6.new(i)
+		end
+		
+		# cmp compares equality with another IPv6. Return:
+		# * 1 if this IPv6 is numerically greater
+		# * 0 if the two are equal
+		# * -1 if this IPv6 is numerically less
+		def cmp(other)
+			if (!other.kind_of?(IPv6))
+				raise ArgumentError, "Expected an IPv6 object for 'other' but got a #{other.class}."
+			end
+			if (self.addr > other.addr)
+				return 1
+			elsif (self.addr < other.addr)
+				return -1
+			end
+			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 = []
+			7.downto(0) do |x|
+				word = (@addr >> 16*x) & 0xffff 
+				words.push( word.to_s(16).rjust(4, "0") )
+			end
+			return words.join(':')
+		end
+		
+		# next returns the next consecutive IPv6 or nil if the address space is exceeded
+		def next()
+			if (self.addr == NetAddr::F128)
+				return nil
+			end
+			return IPv6.new(self.addr + 1)
+		end
+		
+		# prev returns the preceding IPv6 or nil if this is 0.0.0.0
+		def prev()
+			if (self.addr == 0)
+				return nil
+			end
+			return IPv6.new(self.addr - 1)
+		end
+		
+		# to_net returns the IPv6 as a IPv6Net
+		def to_net()
+			NetAddr::IPv6Net.new(self,nil)
+		end
+		
+		# to_s returns the IPv6 as a String in zero-compressed format (per rfc5952).
+		def to_s()
+			hexStr = ["","","","","","","",""]
+			zeroStart, consec0, finalStart, finalLen = -1,0,-1,0
+			8.times do |i|
+				# capture 2-byte word
+				shift = 112 - 16*i
+				wd = (self.addr >> shift) & 0xffff
+				hexStr[i] = wd.to_s(16)
+				
+				# capture count of consecutive zeros
+				if (wd == 0)
+					if (zeroStart == -1)
+						zeroStart = i
+					end
+					consec0 += 1
+				end
+				
+				# test for longest consecutive zeros when non-zero encountered or we're at the end
+				if (wd != 0 || i == 7)
+					if (consec0 > finalStart+finalLen-1)
+						finalStart = zeroStart
+						finalLen = consec0
+					end
+					zeroStart = -1
+					consec0 = 0
+				end
+			end
+			
+			# 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(":")
+				return head + "::" + tail
+			end
+			return hexStr.join(":")
+		end
+		
+		# version returns "6" for IPv6
+		def version()
+			return 6
+		end
+		
+	end # end class IPv6
+	
+end # end module

data/lib/ipv6net.rb

@@ -0,0 +1,267 @@
+module NetAddr
+	
+	#IPv6Net represents an IPv6 network. 
+	class IPv6Net
+		
+		#arguments:
+		#* ip - an IPv6 object
+		#* m128 - a Mask128 object. will default to a /64 if nil
+		def initialize(ip,m128)
+			if (!ip.kind_of?(IPv6))
+				raise ArgumentError, "Expected an IPv6 object for 'ip' but got a #{ip.class}."
+			elsif (m128 != nil && !m128.kind_of?(Mask128))
+				raise ArgumentError, "Expected a Mask128 object for 'm128' but got a #{m128.class}."
+			end
+			
+			if (m128 == nil)
+				if (ip.addr != 0)
+					m128 = Mask128.new(64) # use /64 mask per rfc 4291
+				else
+					m128 = Mask128.new(128) # use /128 mask per rfc 4291
+				end
+			end
+			@m128 = m128
+			@base = IPv6.new(ip.addr & m128.mask)
+		end
+		
+		# parse will create an IPv6Net from its string representation. A default netmask will be used if not specified.
+		# Throws ValidationError on error.
+		def IPv6Net.parse(net)
+			m128 = nil
+			net = net.strip
+			if (net.include?("/")) # cidr format
+				addr,mask = net.split("/")
+				m128 = Mask128.parse(mask)
+			else
+				addr = net
+			end
+			ip = IPv6.parse(addr)
+			return IPv6Net.new(ip,m128)
+		end
+		
+		# cmp compares equality with another IPv6Net. Return:
+		# * 1 if this IPv6Net is numerically greater
+		# * 0 if the two are equal
+		# * -1 if this IPv6Net is numerically less
+		#
+		# The comparison is initially performed on using the cmp() method of the network address, however, in cases where the network
+		# addresses are identical then the netmasks will be compared with the cmp() method of the netmask. 
+		def cmp(other)
+			if (!other.kind_of?(IPv6Net))
+				raise ArgumentError, "Expected an IPv6Net object for 'other' but got a #{other.class}."
+			end
+			cmp = self.network.cmp(other.network)
+			if (cmp != 0)
+				return cmp
+			end
+			return self.netmask.cmp(other.netmask)
+		end
+		
+		#contains returns true if the IPv6Net contains the IPv6
+		def contains(ip)
+			if (!ip.kind_of?(IPv6))
+				raise ArgumentError, "Expected an IPv6 object for 'ip' but got a #{ip.class}."
+			end
+			if (@base.addr == ip.addr & @m128.mask)
+				return true
+			end
+			return false
+		end
+		
+		# fill returns a copy of the given Array, stripped of any networks which are not subnets of this IPv6Net
+		# and with any missing gaps filled in.
+		def fill(list)
+			list = Util.filter_IPv6Net(list)
+			return Util.fill(self,list)
+		end
+		
+		#len returns the number of IP addresses in this network. It will return 0 for /0 networks.
+		def len()
+			return self.netmask.len
+		end
+		
+		# long returns the IPv6Net as a string in long (uncompressed) format
+		def long()
+			return @base.long() + @m128.to_s
+		end
+		
+		# netmask returns the Mask128 object representing the netmask for this network
+		def netmask()
+			@m128
+		end
+			
+		# network returns the IPv6 object representing the network address
+		def network()
+			@base
+		end
+		
+		# next returns the next largest consecutive IP network or nil if the end of the address space is reached.
+		def next()
+			net = self.nth_next_sib(1)
+			if (!net)
+				return nil
+			end
+			return net.grow
+		end
+		
+		# next_sib returns the network immediately following this one or nil if the end of the address space is reached.
+		def next_sib()
+			self.nth_next_sib(1)
+		end
+		
+		# nth returns the IPv6 at the given index.
+		# The size of the network may be determined with the len() method.
+		# If the range is exceeded then return nil.
+		def nth(index)
+			if (!index.kind_of?(Integer))
+				raise ArgumentError, "Expected an Integer for 'index' but got a #{index.class}."
+			elsif (self.netmask.prefix_len < 64 || (self.netmask.prefix_len > 64 && index >= self.len))
+				return nil
+			end
+			return IPv6.new(self.network.addr + index)
+		end
+		
+		# nth_subnet returns the subnet IPv6Net at the given index.
+		# The number of subnets may be determined with the subnet_count() method.
+		# If the range is exceeded  or an invalid prefix_len is provided then return nil.
+		def nth_subnet(prefix_len,index)
+			count = self.subnet_count(prefix_len)
+			if (count == 0 || index >= count)
+				return nil
+			end
+			sub0 = IPv6Net.new(self.network, Mask128.new(prefix_len))
+			return sub0.nth_next_sib(index)
+		end
+		
+		# prev returns the previous largest consecutive IP network or nil if this is ::.
+		def prev()
+			net = self.grow
+			return net.prev_sib
+		end
+		
+		# prev_sib returns the network immediately preceding this one or nil if this network is ::.
+		def prev_sib()
+			if (self.network.addr == 0)
+				return nil
+			end
+			
+			shift = 128 - self.netmask.prefix_len
+			addr = ((self.network.addr>>shift) - 1) << shift
+			if addr < 0
+				return nil
+			end
+			return IPv6Net.new(IPv6.new(addr), self.netmask)
+		end
+		
+		# rel determines the relationship to another IPv6Net. Returns:
+		# * 1 if this IPv6Net is the supernet of other
+		# * 0 if the two are equal
+		# * -1 if this IPv6Net is a subnet of other
+		# * nil if the networks are unrelated
+		def rel(other)
+			if (!other.kind_of?(IPv6Net))
+				raise ArgumentError, "Expected an IPv6Net object for 'other' but got a #{other.class}."
+			end
+			
+			# when networks are equal then we can look exlusively at the netmask
+			if (self.network.addr == other.network.addr)
+				return self.netmask.cmp(other.netmask)
+			end
+			
+			# when networks are not equal we can use hostmask to test if they are
+			# related and which is the supernet vs the subnet
+			hostmask = self.netmask.mask ^ NetAddr::F128
+			otherHostmask = other.netmask.mask ^ NetAddr::F128
+			if (self.network.addr|hostmask == other.network.addr|hostmask)
+				return 1
+			elsif (self.network.addr|otherHostmask == other.network.addr|otherHostmask)
+				return -1
+			end
+			return nil
+		end
+		
+		# resize returns a copy of the network with an adjusted netmask.
+		# Throws ValidationError on invalid prefix_len.
+		def resize(prefix_len)
+			m128 = Mask128.new(prefix_len)
+			return IPv6Net.new(self.network,m128)
+		end
+		
+		# subnet_count returns the number a subnets of a given prefix length that this IPv6Net contains.
+		# It will return 0 for invalid requests (ie. bad prefix or prefix is shorter than that of this network).
+		# It will also return 0 if the result exceeds the capacity of a 128-bit integer (ie. if you want the # of /128 a /0 will hold)
+		def subnet_count(prefix_len)
+			if (prefix_len <= self.netmask.prefix_len || prefix_len > 128 || prefix_len - self.netmask.prefix_len >= 128)
+				return 0
+			end
+			return 1 << (prefix_len - self.netmask.prefix_len)
+		end
+		
+		# summ creates a summary address from this IPv6Net and another.
+		# It returns nil if the two networks are incapable of being summarized.
+		def summ(other)
+			if (!other.kind_of?(IPv6Net))
+				raise ArgumentError, "Expected an IPv6Net object for 'other' but got a #{other.class}."
+			end
+			
+			# netmasks must be identical
+			if (self.netmask.prefix_len != other.netmask.prefix_len)
+				return nil
+			end
+			
+			# merge-able networks will be identical if you right shift them by the number of bits in the hostmask + 1
+			shift = 128 - self.netmask.prefix_len + 1
+			addr = self.network.addr >> shift
+			otherAddr = other.network.addr >> shift
+			if (addr != otherAddr)
+				return nil
+			end
+			return self.resize(self.netmask.prefix_len - 1)
+		end
+		
+		# to_s returns the IPv6Net as a String
+		def to_s()
+			return @base.to_s + @m128.to_s
+		end
+		
+		# version returns "6" for IPv6
+		def version()
+			return 6
+		end
+		
+		
+		protected
+
+		# grow decreases the prefix length as much as possible without crossing a bit boundary.
+		def grow()
+			addr = self.network.addr
+			mask = self.netmask.mask
+			prefix_len = self.netmask.prefix_len
+			self.netmask.prefix_len.downto(0) do
+				mask = (mask << 1) & NetAddr::F128
+				if addr|mask != mask || prefix_len == 0 # // bit boundary crossed when there are '1' bits in the host portion
+					break
+				end
+				prefix_len -= 1
+			end
+			
+			return IPv6Net.new(IPv6.new(addr),Mask128.new(prefix_len))
+		end
+		
+		# nth_next_sib returns the nth next sibling network or nil if address space exceeded.
+		def nth_next_sib(nth)
+			if (nth < 0)
+				return nil
+			end
+			
+			shift = 128 - self.netmask.prefix_len
+			addr = ((self.network.addr>>shift) + nth) << shift
+			if addr > NetAddr::F128
+				return nil
+			end
+			return IPv6Net.new(IPv6.new(addr), self.netmask)
+		end
+
+	end # end class IPv6Net
+	
+end # end module