netaddr 1.4.0 → 1.5.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fd69b081c04694ed2db113b810b07e19ba7f8c9ebe446bca31af3b9f73955777
+  data.tar.gz: 4510ea5730575cbc8f606de4edd21ef054ba661fb9b1b2aacbdfa6f872055ad5
+SHA512:
+  metadata.gz: 12f90e81555cb39d0b51cd10c108b185da1cc4fb48d684858b60e5ada9d3584bb74ec54904335e962a9f14bd194e5c27cee4ab0d017a00ee0a03c223a79d3894
+  data.tar.gz: 78efa87669e4f37defda27d375e57d2dde8cd356b9a9ceac19e0ade7ce080733ee48e766ca100d11c411e7cb87e0d2230c711a24a1db90d73292fff3b69cea18

data/README.md

@@ -0,0 +1,9 @@
+# netaddr
+I originally created this package back in 2007 out of the need for a tool
+which I could use to track an inventory of constantly changing IP subnets.
+At the time, I was in the process of migrating away from Perl and towards Ruby
+as my primary scripting language. I have since migrated away from using Ruby so
+I have not made any major modifications to this code base since 2008 (aside from a 
+handful of bug fixes that others have pointed out).
+ 
+Dustin Spinhirne

data/changelog

@@ -1,8 +1,27 @@
+Version 1.5.2
+Changes:
+* bug fixes from: https://github.com/KirillSmirnov, https://github.com/rwhitworth, https://github.com/y13i
 
-==Version
-====1.3.0
+Version 1.5.1
+Changes:
+* fixed bug with NetAddr#merge (credit to Daniel Boughton)
 
-===New Features
+
+Version 1.5.0
+Changes:
+* fixed bug with EUI48#to_eui64 (credit to Erik Kline)
+* fixed bug with u/l bit toggle on EUI#link_local (credit to Erik Kline)
+* added EUI#to_ipv6
+* added NetAddr#supernets
+
+
+Version 1.4.0
+Changes:
+* Added additional options to NetAddr#sort
+
+
+Version 1.3.0
+New Features:
 * added CIDR#[]
 * added CIDR#succ (CIDR objects may now be used as args for the standard Ruby Range class)
 * added CIDR#allocate_rfc3531
@@ -12,14 +31,12 @@
 * added EUI#to_i
 * added EUI#to_s
 
-===Changes
+Changes:
 * deprecated 'packed' methods
 
 
-==Version
-====1.2.0
-
-===Changes
+Version 1.2.0
+Changes:
 * CIDRv4#new and CIDRv6#new methods have been changed for the sake of speed improvements.
   Please use the CIDR#create method instead.
 * changes to CIDR#wildcard_mask
@@ -28,7 +45,7 @@
 * bug fix and *vast* simplification of NetAddr.merge
 
 
-===New Features
+New Features:
 * speed improvements
 * added CIDR#set_wildcard_mask
 * added <=>, >, <, == methods to CIDR

data/lib/cidr.rb

@@ -1,9 +1,3 @@
-=begin rdoc
- Copyleft (c) 2006 Dustin Spinhirne
-
- Licensed under the same terms as Ruby, No Warranty is provided.
-=end
-
 module NetAddr
 
 #=CIDR - Classless Inter-Domain Routing
@@ -41,9 +35,6 @@ class CIDR
 
 private_class_method :new
 
-#==============================================================================#
-# attr_reader/attr_writer
-#==============================================================================#
 
     # IP version 4 or 6.
     attr_reader :version
@@ -70,10 +61,6 @@ private_class_method :new
         @tag = new_tag
     end
 
-#==============================================================================#
-# create()
-#==============================================================================#
-
 #===Synopsis
 #Create a new CIDRv4 or CIDRv6 object.
 #CIDR formatted netmasks take precedence over extended formatted ones.
@@ -81,21 +68,15 @@ private_class_method :new
 #:Mask takes precedence over netmask given within CIDR addresses.
 #Version will be auto-detected if not specified.
 #
-# NetAddr::CIDR.create('192.168.1.1/24')
-# NetAddr::CIDR.create('192.168.1.1 255.255.255.0')
-# NetAddr::CIDR.create(0x0a010001,
-#                      :Mask => 0xffffff00
-#                      :Version => 4)
-# NetAddr::CIDR.create('192.168.1.1',
-#                      :WildcardMask => ['0.7.0.255', true])
-# NetAddr::CIDR.create('192.168.1.1',
-#                      :WildcardMask => [0x000007ff, true]
-# NetAddr::CIDR.create('192.168.5.0',
-#                      :WildcardMask => ['255.248.255.0'])
-# NetAddr::CIDR.create('fec0::/64')
-# NetAddr::CIDR.create('fec0::/64',
-#                      :Tag => {'interface' => 'g0/1'})
-# NetAddr::CIDR.create('::ffff:192.168.1.1/96')
+#    NetAddr::CIDR.create('192.168.1.1/24')
+#    NetAddr::CIDR.create('192.168.1.1 255.255.255.0')
+#    NetAddr::CIDR.create(0x0a010001,:Mask => 0xffffff00:Version => 4)
+#    NetAddr::CIDR.create('192.168.1.1',:WildcardMask => ['0.7.0.255', true])
+#    NetAddr::CIDR.create('192.168.1.1',:WildcardMask => [0x000007ff, true]
+#    NetAddr::CIDR.create('192.168.5.0',:WildcardMask => ['255.248.255.0'])
+#    NetAddr::CIDR.create('fec0::/64')
+#    NetAddr::CIDR.create('fec0::/64',:Tag => {'interface' => 'g0/1'})
+#    NetAddr::CIDR.create('::ffff:192.168.1.1/96')
 #
 #===Arguments:
 #* addr = CIDR address as a String, or an IP address as an Integer
@@ -221,10 +202,6 @@ private_class_method :new
         return( NetAddr.cidr_build(version, ip, netmask, tag, wildcard_mask, wildcard_mask_bit_flipped) )
     end
 
-#==============================================================================#
-# initialize()
-#==============================================================================#
-
 # This method performs absolutely no error checking, and is meant to be used only by
 # other internal methods for the sake of the speedier creation of CIDR objects.
 # Please consider using #create unless you know what you are doing with 100% certainty.
@@ -267,10 +244,6 @@ private_class_method :new
 
     end
 
-#==============================================================================#
-# <()
-#==============================================================================#
-
 #===Synopsis
 #Compare the sort order of the current CIDR with a provided CIDR and return true
 #if current CIDR is less than provided CIDR.
@@ -307,10 +280,6 @@ private_class_method :new
         return(lt)
     end
 
-#==============================================================================#
-# <=>()
-#==============================================================================#
-
 #===Synopsis
 #Compare the sort order of the current CIDR with a provided CIDR and return:
 #* 1 if the current CIDR is greater than the provided CIDR
@@ -350,10 +319,6 @@ private_class_method :new
         return(comparasin)
     end
 
-#==============================================================================#
-# ==()
-#==============================================================================#
-
 #===Synopsis
 #Compare the sort order of the current CIDR with a provided CIDR and return true
 #if current CIDR is equal to the provided CIDR.
@@ -391,10 +356,6 @@ private_class_method :new
     end
     alias :eql? :==
 
-#==============================================================================#
-# >()
-#==============================================================================#
-
 #===Synopsis
 #Compare the sort order of the current CIDR with a provided CIDR and return true
 #if current CIDR is greater than provided CIDR.
@@ -431,10 +392,6 @@ private_class_method :new
         return(gt)
     end
 
-#==============================================================================#
-# []
-#==============================================================================#
-
 #===Synopsis
 #Provide the IP at the given index of the CIDR.
 #
@@ -463,10 +420,6 @@ private_class_method :new
         return(addr)
     end
 
-#==============================================================================#
-# allocate_rfc3531()
-#==============================================================================#
-
 #===Synopsis
 #RFC 3531 describes a flexible method for IP subnet allocation from
 #a larger parent network. Given the new netmask for subnet allocations from this CIDR,
@@ -564,10 +517,6 @@ private_class_method :new
         return(cidr_list)
     end
 
-#==============================================================================#
-# arpa()
-#==============================================================================#
-
 #===Synopsis
 #Depending on the IP version of the current CIDR,
 #return either an in-addr.arpa. or ip6.arpa. string. The netmask will be used
@@ -624,10 +573,6 @@ private_class_method :new
         return(arpa)
     end
 
-#==============================================================================#
-# bits()
-#==============================================================================#
-
 #===Synopsis
 #Provide number of bits in Netmask.
 # Example:
@@ -644,10 +589,6 @@ private_class_method :new
         return(NetAddr.mask_to_bits(@netmask))
     end
 
-#==============================================================================#
-# cmp()
-#==============================================================================#
-
 #===Synopsis
 #Compare the current CIDR with a provided CIDR and return:
 #* 1 if the current CIDR contains (is supernet of) the provided CIDR
@@ -689,10 +630,6 @@ private_class_method :new
     return(comparasin)
 end
 
-#==============================================================================#
-# contains?()
-#==============================================================================#
-
 #===Synopsis
 #Determines if this CIDR contains (is supernet of)
 #the provided CIDR address or NetAddr::CIDR object.
@@ -732,63 +669,13 @@ end
         return(contains)
     end
 
-#==============================================================================#
-# desc()
-#==============================================================================#
-
 #===Synopsis
-#Returns network/netmask in CIDR format.
-#
-# Example:
-# cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
-# cidr6 = NetAddr::CIDR.create('fec0::/64')
-# cidr4.desc(:IP => true) => "192.168.1.1/24"
-# cidr4.desc() => "192.168.1.0/24"
-# cidr6.desc(:Short => true) => "fec0::/64"
-#
-#===Arguments:
-#* options = Optional hash with the following keys:
-#    :IP -- if true, return the original ip/netmask passed during initialization
-#    :Short -- if true, return IPv6 addresses in short-hand notation
-#
-#===Returns:
-#* String
+#See to_s
 #
     def desc(options=nil)
-        known_args = [:IP, :Short]
-        short = false
-        orig_ip = false
-
-        if (options)
-            if (!options.kind_of? Hash)
-                raise ArgumentError, "Expected Hash, but #{options.class} provided."
-            end
-            NetAddr.validate_args(options.keys,known_args)
-
-            if (options.has_key?(:Short) && options[:Short] == true)
-                short = true
-            end
-
-            if (options.has_key?(:IP) && options[:IP] == true)
-                orig_ip = true
-            end
-        end
-
-        if (!orig_ip)
-            ip = NetAddr.ip_int_to_str(@network, @version)
-        else
-            ip = NetAddr.ip_int_to_str(@ip, @version)
-        end
-        ip = NetAddr.shorten(ip) if (short && @version == 6)
-        mask = NetAddr.mask_to_bits(@netmask)
-
-        return("#{ip}/#{mask}")
+        to_s(options)
     end
 
-#==============================================================================#
-# enumerate()
-#==============================================================================#
-
 #===Synopsis
 #Provide all IP addresses contained within the IP space of this CIDR.
 #
@@ -853,7 +740,7 @@ end
             my_ip = my_ip + bitstep
             change_mask = @hostmask | my_ip
             if (limit)
-                limit = limit -1
+                limit = limit - 1
                 break if (limit == 0)
             end
         end
@@ -861,10 +748,6 @@ end
         return(list)
     end
 
-#==============================================================================#
-# fill_in()
-#==============================================================================#
-
 #===Synopsis
 #Given a list of subnets of the current CIDR, return a new list with any
 #holes (missing subnets) filled in.
@@ -940,10 +823,6 @@ end
         end
     end
 
-#==============================================================================#
-# ip()
-#==============================================================================#
-
 #===Synopsis
 #Provide original IP address passed during initialization.
 #
@@ -966,7 +845,7 @@ end
 
         if (options)
             if (!options.kind_of?(Hash))
-                raise Argumenterror, "Expected Hash, but " +
+                raise ArgumentError, "Expected Hash, but " +
                                      "#{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
@@ -991,10 +870,6 @@ end
         return(ip)
     end
 
-#==============================================================================#
-# is_contained?()
-#==============================================================================#
-
 #===Synopsis
 #Determines if this CIDR is contained within (is subnet of)
 #the provided CIDR address or NetAddr::CIDR object.
@@ -1035,10 +910,6 @@ end
         return(is_contained)
     end
 
-#==============================================================================#
-# last()
-#==============================================================================#
-
 #===Synopsis
 #Provide last IP address in this CIDR object.
 #
@@ -1061,7 +932,7 @@ end
 
         if (options)
             if (!options.kind_of?(Hash))
-                raise Argumenterror, "Expected Hash, but " +
+                raise ArgumentError, "Expected Hash, but " +
                                      "#{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
@@ -1087,10 +958,6 @@ end
         return(ip)
     end
 
-#==============================================================================#
-# matches?()
-#==============================================================================#
-
 #===Synopsis
 #Given an IP address (or if a NetAddr::CIDR object, then the original IP of that object), determine
 #if it falls within the range of addresses resulting from the combination of the 
@@ -1126,10 +993,6 @@ end
         return(false)
     end
 
-#==============================================================================#
-# multicast_mac()
-#==============================================================================#
-
 #===Synopsis
 #Assuming this CIDR is a valid multicast address (224.0.0.0/4 for IPv4 
 #and ff00::/8 for IPv6), return its ethernet MAC address (EUI-48) mapping.
@@ -1185,10 +1048,6 @@ end
         return(eui)
     end
 
-#==============================================================================#
-# netmask()
-#==============================================================================#
-
 #===Synopsis
 #Provide netmask in CIDR format (/yy).
 #
@@ -1207,10 +1066,6 @@ end
         return("/#{bits}")
     end
 
-#==============================================================================#
-# network()
-#==============================================================================#
-
 #===Synopsis
 #Provide base network address.
 #
@@ -1233,7 +1088,7 @@ end
 
         if (options)
             if (!options.kind_of?(Hash))
-                raise Argumenterror, "Expected Hash, but " +
+                raise ArgumentError, "Expected Hash, but " +
                                      "#{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
@@ -1261,10 +1116,6 @@ end
     alias :base :network
     alias :first :network
 
-#==============================================================================#
-# next_ip()
-#==============================================================================#
-
 #===Synopsis
 #Provide the next IP following the last available IP within this CIDR object.
 #
@@ -1291,7 +1142,7 @@ end
 
         if (options)
             if (!options.kind_of?(Hash))
-                raise Argumenterror, "Expected Hash, but " +
+                raise ArgumentError, "Expected Hash, but " +
                                      "#{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
@@ -1326,10 +1177,6 @@ end
         return(next_ip)
     end
 
-#==============================================================================#
-# next_subnet()
-#==============================================================================#
-
 #===Synopsis
 #Provide the next subnet following this CIDR object. The next subnet will
 #be of the same size as the current CIDR object.
@@ -1357,7 +1204,7 @@ end
 
         if (options)
             if (!options.kind_of?(Hash))
-                raise Argumenterror, "Expected Hash, but " +
+                raise ArgumentError, "Expected Hash, but " +
                                      "#{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
@@ -1393,10 +1240,6 @@ end
         return(next_sub)
     end
 
-#==============================================================================#
-# nth()
-#==============================================================================#
-
 #===Synopsis
 #Provide the nth IP within this object.
 #
@@ -1455,10 +1298,6 @@ end
         return(my_ip)
     end
 
-#==============================================================================#
-# range()
-#==============================================================================#
-
 #===Synopsis
 #Given a set of index numbers for this CIDR, return all IP addresses within the
 #CIDR that are between them (inclusive). If an upper bound is not provided, then
@@ -1552,10 +1391,6 @@ end
         return(list)
     end
 
-#==============================================================================#
-# remainder()
-#==============================================================================#
-
 #===Synopsis
 #Given a single subnet of the current CIDR, provide the remainder of
 #the subnets. For example if the original CIDR is 192.168.0.0/24 and you
@@ -1650,10 +1485,6 @@ end
         return(new_subnets)
     end
 
-#==============================================================================#
-# resize()
-#==============================================================================#
-
 #===Synopsis
 #Resize the CIDR by changing the size of the Netmask. 
 #Return the resulting CIDR as a new object.
@@ -1669,7 +1500,7 @@ end
 #* NetAddr::CIDR object
 #
     def resize(bits)
-        raise Argumenterror, "Integer or Hash expected, but " +
+        raise ArgumentError, "Integer or Hash expected, but " +
                              "#{bits.class} provided." if (!bits.kind_of?(Integer))
 
         NetAddr.validate_ip_netmask(bits, :Version => @version)
@@ -1679,10 +1510,6 @@ end
         return( NetAddr.cidr_build(@version, network, netmask) )
     end
 
-#==============================================================================#
-# resize!()
-#==============================================================================#
-
 #===Synopsis
 #Resize the current CIDR by changing the size of the Netmask. The original IP
 #passed during initialization will be set to the base network address if
@@ -1699,7 +1526,7 @@ end
 #* True
 #
     def resize!(bits)
-        raise Argumenterror, "Integer or Hash expected, but " +
+        raise ArgumentError, "Integer or Hash expected, but " +
                                  "#{bits.class} provided." if (!bits.kind_of?(Integer))
 
         NetAddr.validate_ip_netmask(bits, :Version => @version)
@@ -1717,10 +1544,6 @@ end
         return(true)
     end
 
-#==============================================================================#
-# set_wildcard_mask()
-#==============================================================================#
-
 #===Synopsis
 #Set the wildcard mask. Wildcard masks are typically used for matching
 #entries in an access-list.
@@ -1756,10 +1579,6 @@ end
         return(nil)
     end
 
-#==============================================================================#
-# size()
-#==============================================================================#
-
 #===Synopsis
 #Provide number of IP addresses within this CIDR.
 #
@@ -1777,10 +1596,6 @@ end
         return(@hostmask + 1)
     end
 
-#==============================================================================#
-# subnet()
-#==============================================================================#
-
 #===Synopsis
 #Create subnets for this CIDR. There are 2 ways to create subnets:
 #   * By providing the netmask (in bits) of the new subnets with :Bits.
@@ -1928,10 +1743,6 @@ end
         return(new_subnets)
     end
 
-#==============================================================================#
-# succ()
-#==============================================================================#
-
 #===Synopsis
 #Provide the next subnet following this CIDR object. The next subnet will
 #be of the same size as the current CIDR object.
@@ -1959,10 +1770,6 @@ end
         return(next_sub)
     end
 
-#==============================================================================#
-# to_i()
-#==============================================================================#
-
 #===Synopsis
 #Convert the requested attribute of the CIDR to an Integer.
 # Example:
@@ -1995,9 +1802,54 @@ end
         end
     end
 
-#==============================================================================#
-# wildcard_mask()
-#==============================================================================#
+#===Synopsis
+#Returns network/netmask in CIDR format.
+#
+# Example:
+# cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
+# cidr6 = NetAddr::CIDR.create('fec0::/64')
+# cidr4.desc(:IP => true) => "192.168.1.1/24"
+# cidr4.to_s => "192.168.1.0/24"
+# cidr6.to_s(:Short => true) => "fec0::/64"
+#
+#===Arguments:
+#* options = Optional hash with the following keys:
+#    :IP -- if true, return the original ip/netmask passed during initialization
+#    :Short -- if true, return IPv6 addresses in short-hand notation
+#
+#===Returns:
+#* String
+#
+    def to_s(options=nil)
+        known_args = [:IP, :Short]
+        short = false
+        orig_ip = false
+
+        if (options)
+            if (!options.kind_of? Hash)
+                raise ArgumentError, "Expected Hash, but #{options.class} provided."
+            end
+            NetAddr.validate_args(options.keys,known_args)
+
+            if (options.has_key?(:Short) && options[:Short] == true)
+                short = true
+            end
+
+            if (options.has_key?(:IP) && options[:IP] == true)
+                orig_ip = true
+            end
+        end
+
+        if (!orig_ip)
+            ip = NetAddr.ip_int_to_str(@network, @version)
+        else
+            ip = NetAddr.ip_int_to_str(@ip, @version)
+        end
+        ip = NetAddr.shorten(ip) if (short && @version == 6)
+        mask = NetAddr.mask_to_bits(@netmask)
+
+        return("#{ip}/#{mask}")
+    end
 
 #===Synopsis
 #Return the wildcard mask.
@@ -2036,17 +1888,9 @@ class CIDRv4 < CIDR
 
     public_class_method :new
 
-#==============================================================================#
-# broadcast()
-#==============================================================================#
-
 # Alias for last
     alias :broadcast :last
 
-#==============================================================================#
-# hostmask_ext()
-#==============================================================================#
-
 #===Synopsis
 #Provide IPv4 Hostmask in extended format (y.y.y.y).
 #
@@ -2064,10 +1908,6 @@ class CIDRv4 < CIDR
         return(NetAddr.ip_int_to_str(@hostmask, @version))
     end
 
-#==============================================================================#
-# netmask_ext()
-#==============================================================================#
-
 #===Synopsis
 #Provide IPv4 netmask in extended format (y.y.y.y).
 #
@@ -2099,10 +1939,6 @@ end # end class CIDRv4
 class CIDRv6 < CIDR
     public_class_method :new
 
-#==============================================================================#
-# unique_local()
-#==============================================================================#
-
 #===Synopsis
 #Generate an IPv6 Unique Local CIDR address based on the algorithm described
 #in RFC 4193.