ipadmin 0.2.2 → 0.3.0

data/lib/eui.rb

@@ -0,0 +1,381 @@
+=begin rdoc
+ Copyright (c) 2006 Dustin Spinhirne -  
+ Licensed under the same terms as Ruby, No Warranty is provided.
+=end
+
+
+module IPAdmin
+class EUI
+
+# instance variables
+# @type - eui-48 or eui-64
+# @oui - Organizationally Unique Identifier 
+# @ei - Extention Identifier
+
+#==============================================================================#
+# initialize()
+#==============================================================================#
+
+# - Arguments:
+#   * Hash with the following fields:
+#       - :EUI -- Extended Unique Identifier - String (optional)
+#       - :PackedEUI -- Integer representing an Extended Unique Identifier (optional)
+#       - :Length --  bit length of PackedEUI - Integer (optional)
+#
+# - Note:
+#   * At a minimum, EUI or PackedEUI must be provided.
+#   * PackedEUI takes precedence over EUI.
+#   * Length is only needed when using PackedEUI
+#
+# Example:
+#   addr = IPAdmin::EUI.new(:EUI => 'aa-bb-cc-dd-ee-ff')
+#   addr = IPAdmin::EUI.new(:EUI => 'aa:bb:cc:dd:ee:ff')
+#   addr = IPAdmin::EUI.new(:EUI => 'aabb.ccdd.eeff')
+#   addr = IPAdmin::EUI.new(:EUI => 'aa-bb-cc-dd-ee-ff-00-01')
+#
+    def initialize(options)
+        if (!options.kind_of? Hash)
+            raise ArgumentError, "Expected Hash, but #{options.class} provided."
+        end
+        
+        if (options.has_key?(:PackedEUI))
+            packed_eui = options[:PackedEUI]
+            
+            if (options.has_key?(:Length) && options[:Length].kind_of?(Integer))
+                @type = options[:Length]
+                @type = 48 if (@type != 48 && @type != 64)
+            else
+                @type = 48
+            end
+        
+            if (packed_eui.kind_of?(Integer))
+                if (@type == 48)
+                    @oui = packed_eui >> 24
+                    @ei = packed_eui & 0xffffff
+                else
+                    @oui = packed_eui >> 40
+                    @ei = packed_eui & 0xffffffffff
+                end
+            else
+                raise ArgumentError, "Expected Integer, but #{eui.class} " +
+                                     "provided for argument :PackedEUI."
+            end
+            
+        elsif(options.has_key?(:EUI))
+            eui = options[:EUI]
+            
+            if (eui.kind_of?(String))
+                # validate
+                IPAdmin.validate_eui(:EUI => eui)
+            
+                # remove formatting characters
+                eui.gsub!(/[\.\:\-]/, '')           
+            
+                # check if eui-48 or eui-64
+                if (eui.length == 12)
+                    @type = 48
+                elsif (eui.length == 16)
+                    @type = 64
+                else
+                    raise "#{eui} is invalid (address is neither EUI-48 nor EUI-64)."
+                end
+            
+                # split into oui & ei, pack, and store
+                @oui = eui.slice!(0..5).to_i(16)
+                @ei = eui.to_i(16)
+        
+            else
+                raise ArgumentError, "Expected String, but #{eui.class} " +
+                                     "provided for argument :EUI."
+            end
+            
+        else
+            raise ArgumentError, "Missing argument: [EUI|PackedEUI]."
+        end
+  
+    end
+
+#======================================#
+#
+#======================================#
+
+
+#==============================================================================#
+# address()
+#==============================================================================#
+
+# Returns EUI address.
+#
+# - Arguments:
+#   * Optional hash with the following fields:
+#       - :Delimiter -- delimitation character. valid values are (-,:,and .) (optional)
+#
+# - Returns:
+#   * String
+#
+# Example:
+#   puts addr.address(:Delimiter => '.')   --> 'aabb.ccdd.eeff'
+#
+    def address(options=nil)
+        delimiter = '-'
+        
+        octets = []
+        octets.concat(unpack_oui)
+        octets.concat(unpack_ei)
+        
+        if (options)
+            if (!options.kind_of? Hash)
+                raise ArgumentError, "Expected Hash, but #{options.class} provided."
+            end
+        
+            if (options.has_key?(:Delimiter))
+                delimiter = options[:Delimiter]
+                delimiter = '-' if (delimiter != '-' && delimiter != ':' && delimiter != '.' )
+            end
+        end
+        
+        if (delimiter == '-' || delimiter == ':')
+                    address = octets.join(delimiter)
+        elsif (delimiter == '.')                
+                toggle = 0
+                octets.each do |x|
+                    if (!address)
+                        address = x
+                        toggle = 1
+                    elsif (toggle == 0)
+                        address = address  << '.' << x
+                        toggle = 1
+                    else
+                        address = address << x
+                        toggle = 0
+                    end
+                end 
+
+        end
+        
+        return(address)       
+    end
+
+#======================================#
+#
+#======================================#
+
+
+#==============================================================================#
+# ei()
+#==============================================================================#
+
+# Returns Extended Identifier portion of an EUI address (the vendor assigned ID).
+#
+# - Arguments:
+#   * Optional hash with the following fields:
+#       - :Delimiter -- delimitation character. valid values are (-, and :) (optional)
+#
+# - Returns:
+#   * String
+#
+# Example:
+#   puts addr.ei(:Delimiter => '-')   --> 'aa-bb-cc'
+#
+    def ei(options=nil)
+        octets = unpack_ei()
+        delimiter = '-'
+        
+        if (options)
+            if (!options.kind_of? Hash)
+                raise ArgumentError, "Expected Hash, but #{options.class} provided."
+            end
+        
+            if (options.has_key?(:Delimiter))
+                if (options[:Delimiter] == ':')
+                    delimiter = options[:Delimiter]
+                end
+            end
+        end
+        ei = octets.join(delimiter)
+        
+        return(ei)       
+    end
+
+#======================================#
+#
+#======================================#
+
+
+#==============================================================================#
+# link_local()
+#==============================================================================#
+
+# Provide an IPv6 Link Local address based on the current EUI address.
+#
+# - Arguments:
+#   * Optional hash with the following fields:
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#       - :Objectify -- if true, return CIDR objects (optional)
+#
+# - Returns:
+#   * String
+#
+# Example:
+#   puts addr.link_local() --> fe80:0000:0000:0000:aabb:ccff:fedd:eeff
+#
+    def link_local(options=nil)        
+        objectify = false
+        short = false
+                
+        if (options)
+            if (!options.kind_of? Hash)
+                raise ArgumentError, "Expected Hash, but #{options.class} provided."
+            end
+        
+            if (options.has_key?(:Objectify) && options[:Objectify] == true)
+                objectify = true
+            end
+            
+            if (options.has_key?(:Short) && options[:Short] == true)
+                short = true
+            end
+        end
+        
+        if (@type == 48)
+            link_local = @ei | 0xfffe000000 | (@oui << 40)
+        else
+            link_local = @ei | (@oui << 40)
+        end
+        link_local = link_local | (0xfe80 << 112)
+        
+        if (!objectify)
+            link_local = IPAdmin.unpack_ip_addr(:Integer => link_local, :Version => 6)
+            link_local = IPAdmin.shorten(link_local) if (short)
+        else
+            link_local = IPAdmin::CIDR.new(:PackedIP => link_local,  
+                                           :Version => 6)
+        end
+        
+        return(link_local)
+    end
+
+#======================================#
+#
+#======================================#
+
+
+#==============================================================================#
+# oui()
+#==============================================================================#
+
+# Returns Organizationally Unique Identifier portion of an EUI address (the vendor ID).
+#
+# - Arguments:
+#   * Optional hash with the following fields:
+#       - :Delimiter -- delimitation character. valid values are (-, and :) (optional)
+#
+# - Returns:
+#   * String
+#
+# Example:
+#   puts addr.oui(:Delimiter => '-')   --> 'dd-ee-ff'
+#
+    def oui(options=nil)
+        octets = unpack_oui()
+        delimiter = '-'
+        
+        if (options)
+            if (!options.kind_of? Hash)
+                raise ArgumentError, "Expected Hash, but #{options.class} provided."
+            end
+        
+            if (options.has_key?(:Delimiter))
+                if (options[:Delimiter] == ':')
+                    delimiter = options[:Delimiter]
+                end
+            end
+        end
+        oui = octets.join(delimiter)
+        
+        return(oui)                
+    end
+
+#======================================#
+#
+#======================================#
+
+
+#==============================================================================#
+# type()
+#==============================================================================#
+
+# Provide address type (EUI-48 or EUI-64).
+#
+# - Arguments:
+#   * none
+#
+# - Returns:
+#   * String
+#
+# Example:
+#   puts addr.type   --> EUI-48
+#
+    def type()
+        if (@type == 48)
+            return('EUI-48')
+        else
+            return('EUI-64')
+        end        
+    end
+
+#======================================#
+#
+#======================================#
+
+
+
+# PRIVATE METHODS
+private
+
+#==============================================================================#
+# unpack_ei()
+#==============================================================================#
+
+    def unpack_ei()
+        hex = @ei
+        octets = []
+        loop_count = (@type - 24)/8
+        loop_count.times do
+           octet = (hex & 0xff).to_s(16)
+           octet = '0' << octet if (octet.length != 2)
+           octets.unshift(octet)
+           hex = hex >> 8 
+        end
+        return(octets)
+    end
+
+#======================================#
+#
+#======================================#
+
+
+#==============================================================================#
+# unpack_oui()
+#==============================================================================#
+
+    def unpack_oui()
+        hex = @oui
+        octets = []
+        3.times do
+           octet = (hex & 0xff).to_s(16)
+           octet = '0' << octet if (octet.length != 2)
+           octets.unshift(octet)
+           hex = hex >> 8 
+        end
+        return(octets)
+    end
+
+#======================================#
+#
+#======================================#
+
+end
+
+end # module IPAdmin
+__END__

data/lib/ip_admin.rb

@@ -1,5 +1,5 @@
 =begin rdoc
- Copyright (c) 2006 Dustin Spinhirne <http://www.spinhirne.com> -  
+ Copyright (c) 2006 Dustin Spinhirne -  
  Licensed under the same terms as Ruby, No Warranty is provided.
 =end
 
@@ -7,5 +7,6 @@
 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')
 
 __END__

data/lib/methods.rb

@@ -154,6 +154,12 @@ module_function :create_net_struct
 # - Returns:
 #   * Array of CIDR or NetStruct objects
 #
+# - Notes:
+#   * I have designed this with enough flexibility that you can pass in CIDR 
+#     addresses that arent even related (ex. 192.168.1.0/26, 192.168.1.64/26,
+#     10.1.0.0/26, 10.1.0.64/26) and they will be merged properly (ie 192.168.1.0/25,
+#     and 10.1.0.0/25 would be returned).
+#
 # Example:
 #   supernets = IPAdmin.merge(:List => list)
 #
@@ -171,11 +177,11 @@ def merge(options)
         raise ArgumentError, "Missing argument: List."
     end
     
-    if (options.has_key?(:Short))
+    if (options.has_key?(:Short) && options[:Short] == true)
         short = true
     end
     
-    if (options.has_key?(:Objectify))
+    if (options.has_key?(:Objectify) && options[:Objectify] == true)
         objectify = true
     end
 
@@ -685,11 +691,11 @@ def range(options)
             bitstep = options[:Bitstep]
         end
 
-        if( options.has_key?(:Objectify) )
+        if( options.has_key?(:Objectify) && options[:Objectify] == true )
             objectify = true
         end
         
-        if( options.has_key?(:Short) )
+        if( options.has_key?(:Short) && options[:Short] == true )
             short = true
         end
 
@@ -1115,6 +1121,71 @@ module_function :unshorten
 #======================================#
 
 
+#==============================================================================#
+# validate_eui()
+#==============================================================================#
+
+# Validate an EUI-48 or EUI-64 address. 
+#
+# - Arguments
+#   * Hash with the following fields:
+#       - :EUI -- Address to validate - String
+#
+# - Returns:
+#   * True
+#
+# - Example:
+#   * IPAdmin.validate_eui(:EUI => '01-00-5e-12-34-56')
+#
+def validate_eui(options)
+    if (!options.kind_of? Hash)
+        raise ArgumentError, "Expected Hash, but #{options.class} provided."
+    end
+        
+    if (!options.has_key?(:EUI))
+        raise ArgumentError, "Missing argument: EUI."
+    end
+    eui = options[:EUI]
+        
+    if (eui.kind_of?(String))
+        # check for invalid characters
+        if (eui =~ /[^0-9a-fA-f\.\-\:]/)
+            raise "#{eui} is invalid (contains invalid characters)."
+        end
+            
+        # split on formatting characters & check lengths
+        if (eui =~ /\-/)
+            fields = eui.split('-')
+            if (fields.length != 6 && fields.length != 8)
+                raise "#{eui} is invalid (unrecognized formatting)."
+            end 
+        elsif (eui =~ /\:/)
+            fields = eui.split(':')
+            if (fields.length != 6 && fields.length != 8)
+                raise "#{eui} is invalid (unrecognized formatting)."
+            end
+        elsif (eui =~ /\./)
+            fields = eui.split('.')
+            if (fields.length != 3 && fields.length != 4)
+                raise "#{eui} is invalid (unrecognized formatting)."
+            end
+        else
+            raise "#{eui} is invalid (unrecognized formatting)."
+        end
+
+    else
+        raise ArgumentError, "Expected String, but #{eui.class} " +
+                             "provided for argument :EUI."
+    end
+    return(true)
+end
+module_function :validate_eui
+
+#======================================#
+#
+#======================================#
+
+
 #==============================================================================#
 # validate_ip_addr()
 #==============================================================================#
@@ -1432,737 +1503,6 @@ NetStruct = Struct.new(:network, :netmask, :version, :object, :subnets)
 #======================================#
 
 
-
-
-
-# DEPRICATED
-
-#==============================================================================#
-# arpa()
-#==============================================================================#
-
-# DEPRICATED - USE CIDR.arpa: 
-# Using the provided CIDR object, 
-# return either an in-addr.arpa. or ip6.arpa. string. The netmask will be used
-# to determine the length of the returned arpa string.
-#
-# - Arguments:
-#   * CIDR object
-#
-# - Returns:
-#   * String
-#
-# - Notes:
-#   * IPAdmin.arpa will use the original IP address passed during the initialization
-#     of the CIDR objects. This IP can be found using the CIDR.ip() method.
-#
-# Example:
-#   arpa = IPAdmin.arpa(cidr)
-#
-def arpa(object)
-
-    if (!object.kind_of? IPAdmin::CIDR)
-        raise ArgumentError, "Expected IPAdmin::CIDR object, " +
-                             "but #{object.class} provided."
-    end
-
-    base = object.ip()
-    netmask = object.bits()
-
-    if (object.version == 4)
-        net = base.split('.')
-
-        if (netmask)
-            while (netmask < 32)
-                net.pop
-                netmask = netmask + 8
-            end
-        end
-
-        arpa = net.reverse.join('.')
-        arpa << ".in-addr.arpa."
-
-    elsif (object.version == 6)
-        fields = base.split(':')
-        net = []
-        fields.each do |field|
-            (field.split("")).each do |x|
-                net.push(x)
-            end
-        end
-
-        if (netmask)
-            while (netmask < 128)
-                net.pop
-                netmask = netmask + 4
-            end
-        end
-
-        arpa = net.reverse.join('.')
-        arpa << ".ip6.arpa."
-
-    end
-
-    return(arpa)
-end
-module_function :arpa
-
-#======================================#
-#
-#======================================#
-
-#==============================================================================#
-# validate_ipv4_addr()
-#==============================================================================#
-
-# DEPRICATED - USE validate_ip_addr INSTEAD
-# Validate IPv4 addresses. The address should not contain a netmask.
-#
-# - Arguments:
-#   * IPv4 address
-#
-# - Returns:
-#   * packed IP on valid, or exception on error.
-#
-# Example:
-#   IPAdmin.validate_ipv4_addr('192.168.1.1')
-#
-def validate_ipv4_addr(ip)
-
-    # is this a string?
-    unless (ip.kind_of? String)
-        raise ArgumentError, "Expected String, but #{ip.class} provided."
-    end
-
-    # check validity of characters in the addr
-    if ( (ip =~ /\.{2,}?/ ) || (ip =~ /[^0-9\.]/) )
-        raise "#{ip} is not a valid IPv4 address."
-    end
-
-    # do we have 4 octets?
-    octets = ip.split( /\./ ).reverse
-    if (octets.length != 4)
-        raise "#{ip} is not a valid IPv4 address."
-    end
-
-    # are octets in range 0..255?
-    packed_ip = 0
-    (0..3).each do |x|
-        octets[x] = octets[x].to_i
-        unless ( (octets[x] >= 0) && (octets[x] < 256 ) )
-            raise "#{ip} is not a valid IPv4 address." 
-        end
-        octets[x] =  octets[x] << 8*x 
-        packed_ip = packed_ip | octets[x]
-    end
-
-    # dont allow first octet to be 0
-    if (octets[3] == 0)
-        raise "#{ip} is not a valid IPv4 address." 
-    end
-
-    return(packed_ip)
-
-end
-module_function :validate_ipv4_addr
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# validate_ipv4_netmask()
-#==============================================================================#
-
-# DEPRICATED - USE validate_ip_netmask INSTEAD
-# Validate IPv4 Netmask.
-#
-# - Arguments:
-#   * IPv4 netmask in cidr or extended notation
-#
-# - Returns:
-#   * packed netmask on valid, or exception on error.
-#
-# Example:
-#   IPAdmin.validate_ipv4_netmask('255.255.255.0')
-#   IPAdmin.validate_ipv4_netmask('24')
-#   IPAdmin.validate_ipv4_netmask('/24')
-#   IPAdmin.validate_ipv4_netmask(24)
-#
-def validate_ipv4_netmask(netmask)
-    all_f = 2**32 - 1
-    packed_mask = nil
-
-    # is this a CIDR or Extended mask?
-    if(netmask =~ /\./)
-        # validate & pack extended mask
-        begin
-            validate_ipv4_addr(netmask)
-            packed_netmask = pack_ipv4_addr(netmask)
-
-            rescue Exception 
-            raise "#{netmask} is not a valid IPv4 netmask."
-        end
-
-        # cycle through the bits of hostmask and compare
-        # with packed_mask. when we hit the firt '1' within
-        # packed_mask (our netmask boundary), xor hostmask and
-        # packed_mask. the result should be all 1's. this whole
-        # process is in place to make sure that we dont have
-        # and crazy masks such as 255.254.255.0
-        hostmask = 1
-        32.times do 
-            check = packed_netmask & hostmask
-            if ( check != 0)
-                hostmask = hostmask >> 1
-                unless ( (packed_netmask ^ hostmask) == all_f)
-                    raise "#{netmask} is not a valid IPv4 netmask." 
-                end
-                break
-            else
-                hostmask = hostmask << 1
-                hostmask = hostmask | 1
-            end
-        end
-
-    else
-        # remove '/' if present
-        if (netmask =~ /^\// )
-            netmask[0] = " "
-            netmask.lstrip!
-        end
-
-        # check if we have any non numeric characters
-        if (netmask =~ /\D/)
-            raise "#{netmask} is not a valid IPv4 netmask."
-        end
-
-        # are we between 1 and 32 inclusive
-        if (netmask.kind_of? String)
-            netmask = netmask.to_i
-        end
-
-        if ( (netmask > 32) || (netmask == 0) )
-            raise "#{netmask} is not a valid IPv4 netmask." 
-        end
-
-        packed_netmask = all_f ^ (all_f >> netmask)
-    end
-
-    return(packed_netmask)
-end
-module_function :validate_ipv4_netmask
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# validate_ipv6_addr()
-#==============================================================================#
-
-# DEPRICATED - USE validate_ip_addr INSTEAD
-# Validate IPv6 addresses. The address should not contain a netmask.
-#
-# - Arguments:
-#   * IPv6 address
-#
-# - Returns:
-#   * packed IP on valid, or exception on error.
-#
-# Example:
-#   IPAdmin.validate_ipv6_addr('fec0::')
-#
-def validate_ipv6_addr(ip)
-    # is this a string?
-    unless (ip.kind_of? String)
-        raise ArgumentError, "Expected String, but #{ip.class} provided."
-    end
-
-    # check validity of characters in the addr
-    if ( (ip =~ /:{3,}?/ ) || (ip =~ /[^0-9a-fA-F:]/) )
-        raise "#{ip} is not a valid IPv6 address."
-    end
-
-    # look for a '::' to see if this address is in shorthand
-    # if found, split on it & make sure that we have at most
-    # two elements
-    if (ip =~ /::/)
-        shrthnd = ip.split( /::/ ) 
-        unless ( (shrthnd.length > 0) && (shrthnd.length < 3) )
-            raise "#{ip} is not a valid IPv6 address."
-        end
-    end
-
-    if (shrthnd)
-        # if shorthand, we should have between 1 and 7
-        # hex fields
-        hex_fields = []
-        shrthnd.each do |x|
-            elements = x.split( /:/ )
-            elements.each {|x| hex_fields.push(x)}
-        end
-        if ( (hex_fields.length < 1) || (hex_fields.length > 7) )
-            raise "#{ip} is not a valid IPv6 address."
-        end
-
-     else
-        # since no shorthand notation was detected we should
-        # have exactly 8 hex fields
-        hex_fields = ip.split( /:/ )
-        if (hex_fields.length != 8)
-            raise "#{ip} is not a valid IPv6 address."
-        end
-
-    end
-
-    # check that we have no more than 4 characters in each 
-    # hex field
-    hex_fields.each do |x|
-        if (x.length > 4)
-            raise "#{ip} is not a valid IPv6 address."
-        end
-    end
-
-    packed_ip = IPAdmin.pack_ipv6_addr(ip)
-    return(packed_ip)
-end
-module_function :validate_ipv6_addr
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# validate_ipv6_netmask()
-#==============================================================================#
-
-# DEPRICATED - USE validate_ip_netmask INSTEAD
-# Validate IPv6 netmask.
-#
-# - Arguments:
-#   * IPv6 netmask in cidr notation
-#
-# - Returns:
-#   * packed netmask on valid, or exception on error.
-#
-# Example:
-#   IPAdmin.validate_ipv6_netmask('64')
-#   IPAdmin.validate_ipv6_netmask('/64')
-#   IPAdmin.validate_ipv6_netmask(64)
-#
-def validate_ipv6_netmask(netmask)
-    all_f = 2**128 -1
-
-    # remove '/' if present
-    if (netmask =~ /^\// )
-        netmask[0] = " "
-        netmask.lstrip!
-    end
-
-    if (netmask =~ /\D/)
-        raise "#{netmask} is not a valid IPv6 netmask."
-
-    else
-        # are we between 1 and 128 inclusive
-        if (netmask.kind_of? String)
-            netmask = netmask.to_i
-        end
-
-        if ( (netmask > 128) || (netmask == 0) )
-            raise "#{netmask} is not a valid IPv6 netmask." 
-        end
-
-    end
-
-    packed_netmask = all_f ^ (all_f >> netmask)
-    return(packed_netmask)
-end
-module_function :validate_ipv6_netmask
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# pack_ipv4_addr()
-#==============================================================================#
-
-# DEPRICATED - USE pack_ip_addr INSTEAD
-# Convert IPv4 addresses into an integer. No attempt at
-# validation is performed.
-#
-# - Arguments:
-#   * IPv4 address
-#
-# - Returns:
-#   * packed IPv4 address or exception on error.
-#
-# Example:
-#   packed = IPAdmin.pack_ipv4_addr('192.168.1.1')
-#
-def pack_ipv4_addr(ip)
-
-    # is this a string?
-    unless (ip.kind_of? String)
-        raise ArgumentError, "Expected String, but #{ip.class} provided."
-    end
-
-    # pack our ip
-    octets = ip.split( /\./ ).reverse
-    packed_ip = 0
-
-    (0..3).each do |x|
-        octets[x] = (octets[x]).to_i
-        octets[x] =  octets[x] << 8*x 
-        packed_ip = packed_ip | octets[x]
-    end
-
-    return(packed_ip)
-end
-module_function :pack_ipv4_addr
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# pack_ipv4_netmask()
-#==============================================================================#
-
-# DEPRICATED - USE pack_ip_netmask INSTEAD
-# Convert IPv4 netmask into an integer.  Only very basic
-# validation is performed.
-#
-# - Arguments:
-#   * IPv4 netmask in cidr or extended notation
-#
-# - Returns:
-#   * packed IPv4 netmask or exception on error.
-#
-# Example:
-#   packed = IPAdmin.pack_ipv4_netmask('255.255.255.0')
-#   packed = IPAdmin.pack_ipv4_netmask('24')
-#   packed = IPAdmin.pack_ipv4_netmask('/24')
-#   packed = IPAdmin.pack_ipv4_netmask(24)
-#
-def pack_ipv4_netmask(netmask)
-    all_f = 2**32-1
-
-    # is this a CIDR or Extended mask?
-    if(netmask =~ /\./)
-        # pack extended mask
-        begin
-            packed_netmask = pack_ipv4_addr(netmask)
-            rescue Exception 
-            raise "#{netmask} is not a valid IPv4 netmask."
-        end
-
-    else
-        # remove '/' if present
-        if (netmask =~ /^\// )
-            netmask[0] = " "
-            netmask.lstrip!
-        end
-
-        # check if we have any non numeric characters
-        if (netmask =~ /\D/)
-            raise "#{netmask} is not a valid IPv4 netmask."
-        end
-
-        if (netmask.kind_of? String)
-            netmask = netmask.to_i
-        end
-
-        packed_netmask = all_f ^ (all_f >> netmask)
-    end
-
-    return(packed_netmask)
-end
-module_function :pack_ipv4_netmask
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# pack_ipv6_addr()
-#==============================================================================#
-
-# DEPRICATED - USE pack_ip_addr INSTEAD
-# Convert IPv6 addresses into an integer. No attempt at 
-# validation is performed.
-#
-# - Arguments:
-#   * IPv6 address
-#
-# - Returns:
-#   * packed IPv6 address or exception on error.
-#
-# Example:
-#   packed = IPAdmin.pack_ipv6_addr('fec0::1')
-#
-def pack_ipv6_addr(ip)
-    # is this a string?
-    unless (ip.kind_of? String)
-        raise ArgumentError, "Expected String, but #{ip.class} provided."
-    end
-
-    # look for a '::' to see if this address is in shorthand
-    # if found, split on it
-    hex_fields = []
-    if (ip =~ /::/)
-        shrthnd = ip.split( /::/ )
-        if (ip =~  /^::/)
-            sec_half = shrthnd[1].split( /:/ )
-            zero_pads = 8 - sec_half.length
-            (1..zero_pads).each {hex_fields.push('0')}
-            sec_half.each {|field| hex_fields.push(field)}
-        elsif (ip =~  /::$/)
-            hex_fields = shrthnd[0].split( /:/ )
-            zero_pads = 8 - hex_fields.length
-            (1..zero_pads).each {hex_fields.push('0')}
-        else
-            first_half = shrthnd[0].split( /:/ )
-            sec_half = shrthnd[1].split( /:/ )
-            zero_pads = 8 - (first_half.length + sec_half.length)
-            first_half.each {|field| hex_fields.push(field)}
-            (1..zero_pads).each {hex_fields.push('0')}
-            sec_half.each {|field| hex_fields.push(field)}
-        end
-
-    else
-        hex_fields = ip.split( /:/ )
-    end
-
-    # pack
-    hex_fields.reverse!
-    packed_ip = 0
-    (0..7).each do |x|
-        hex = hex_fields[x]
-        base16 = hex.to_i(16)
-
-        base16 =  base16 << 16*x 
-        packed_ip = packed_ip | base16
-    end
-
-
-    return(packed_ip)
 end
-module_function :pack_ipv6_addr
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# pack_ipv6_netmask()
-#==============================================================================#
-
-# DEPRICATED - USE pack_ip_netmask INSTEAD
-# Convert IPv6 netmask into an integer. Only very basic 
-# validation is performed.
-#
-# - Arguments:
-#   * IPv6 netmask in cidr notation
-#
-# - Returns:
-#   * packed IPv6 netmask or exception on error.
-#
-# Example:
-#   packed = IPAdmin.pack_ipv6_netmask('64')
-#   packed = IPAdmin.pack_ipv6_netmask('/64')
-#   packed = IPAdmin.pack_ipv6_netmask(64)
-#
-def pack_ipv6_netmask(netmask)
-    all_f = 2**128-1
-
-    # remove '/' if present
-    if (netmask =~ /^\// )
-        netmask[0] = " "
-        netmask.lstrip!
-    end
-
-    if (netmask !~ /\D/)   
-        # pack
-        if (netmask.kind_of? String)
-            netmask = netmask.to_i
-        end
-
-        packed_netmask = all_f ^ (all_f >> netmask)
-
-    else
-        raise "#{netmask} is not a valid IPv6 netmask."
-
-    end
-
-    return(packed_netmask)
-end
-module_function :pack_ipv6_netmask
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# unpack_ipv4_addr()
-#==============================================================================#
-
-# DEPRICATED - USE unpack_ip_addr INSTEAD
-# Unack a packed IPv4 address back into a printable string. No attempt at
-# validation is performed.
-#
-# - Arguments:
-#   * Byte-packed IPv4 address
-#
-# - Returns:
-#   * IPv4 address.
-#
-# Example:
-#   unpacked = IPAdmin.unpack_ipv4_addr(packed)
-#
-def unpack_ipv4_addr(packed_ip)
-    octets = []
-    (0..3).each do |x|
-        octets[x] = packed_ip & 0xFF
-        octets[x] = (octets[x]).to_s
-        packed_ip = packed_ip >> 8
-    end
-
-    octets.reverse!
-    ip = octets.join('.')
-
-    return(ip)
-end
-module_function :unpack_ipv4_addr 
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# unpack_ipv4_netmask()
-#==============================================================================#
-
-# DEPRICATED - USE unpack_ip_netmask INSTEAD
-# Unack a packed IPv4 netmask into a integer representing the number of
-# bits in the CIDR mask. No attempt at validation is performed.
-#
-# - Arguments:
-#   * Byte-packed IPv4 netmask
-#
-# - Returns:
-#   * IPv4 netmask as number of bits (cidr format).
-#
-# Example:
-#   unpacked = IPAdmin.unpack_ipv4_netmask(packed)
-#
-def unpack_ipv4_netmask(packed_mask)
-    mask = 32
-    32.times do    
-        if ( (packed_mask & 1) != 0)
-            break
-        end
-        packed_mask = packed_mask >> 1
-        mask = mask - 1
-    end
-
-    return(mask)
-end
-module_function :unpack_ipv4_netmask 
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# unpack_ipv6_addr()
-#==============================================================================#
-
-# DEPRICATED - USE unpack_ip_addr INSTEAD
-# Unack a packed IPv6 address back into a printable string. No attempt at 
-# validation is performed.
-#
-# - Arguments:
-#   * Byte-packed IPv6 address
-#
-# - Returns:
-#   * IPv6 address.
-#
-# Example:
-#   unpacked = IPAdmin.unpack_ipv6_addr(packed)
-#
-def unpack_ipv6_addr(packed_ip)
-    hex_fields = []
-    (0..7).each do |x|
-        hex_fields[x] = packed_ip & 0xFFFF
-        hex_fields[x] = (hex_fields[x]).to_s(16)
-        packed_ip = packed_ip >> 16
-
-        # if hex_fields[x] < 4 characters, then pad with 0's
-        (4 - hex_fields[x].length).times do
-            hex_fields[x] = '0' << hex_fields[x]
-        end
-    end
-
-    hex_fields.reverse!
-    ip = hex_fields.join(':')
-
-    return(ip)
-end
-module_function :unpack_ipv6_addr 
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# unpack_ipv6_netmask()
-#==============================================================================#
-
-# DEPRICATED - USE unpack_ip_netmask INSTEAD
-# Unack a packed IPv6 netmask into a integer representing the number of
-# bits in the CIDR mask. No attempt at validation is performed.
-#
-# - Arguments:
-#   * Byte-packed IPv6 netmask
-#
-# - Returns:
-#   * IPv6 netmask as number of bits (cidr format).
-#
-# Example:
-#   unpacked = IPAdmin.unpack_ipv6_netmask(packed)
-#
-def unpack_ipv6_netmask(packed_mask)
-
-    mask = 128
-    128.times do
-        if ( (packed_mask & 1) == 1)
-            break
-        end
-        mask = mask - 1
-        packed_mask = packed_mask >> 1
-    end
-
-    return(mask)
-end
-module_function :unpack_ipv6_netmask 
-
-#======================================#
-#
-#======================================#
-
-end # module IPAdmin
 __END__