netaddr 1.5.1 → 2.0.1

data/lib/cidr_shortcuts.rb

@@ -1,440 +0,0 @@
-module NetAddr
-private
-
-# CIDR METHODS
-
-#==============================================================================#
-# cidr_build()
-#==============================================================================#
-
-# create either a CIDRv4 or CIDRv6 object
-#
-def cidr_build(version, ip, netmask=nil, tag={}, wildcard_mask=nil, wildcard_mask_bit_flipped=false)
-     return( NetAddr::CIDRv4.new(ip, netmask, tag, wildcard_mask, wildcard_mask_bit_flipped) ) if (version == 4)
-     return( NetAddr::CIDRv6.new(ip, netmask, tag, wildcard_mask, wildcard_mask_bit_flipped) )
-end
-module_function :cidr_build
-
-#==============================================================================#
-# cidr_compare()
-#==============================================================================#
-
-# compare 2 CIDR objects
-#
-#return:
-#* 1 if the cidr1 contains cidr2
-#* 0 if the cidr1 and cidr2 are equal
-#* -1 if cidr1 is a subnet of cidr2
-#* nil if the two are unrelated
-#
-def cidr_compare(cidr1,cidr2)
-    comparasin = nil
-    if ( cidr1.to_i(:network) == cidr2.to_i(:network) )
-        # same network, check netmask
-        if (cidr1.to_i(:netmask) == cidr2.to_i(:netmask) )
-            comparasin = 0
-        elsif(cidr1.to_i(:netmask) < cidr2.to_i(:netmask))
-            comparasin = 1
-        elsif(cidr1.to_i(:netmask) > cidr2.to_i(:netmask))
-            comparasin = -1
-        end
-
-    elsif( (cidr2.to_i(:network) | cidr1.to_i(:hostmask)) == (cidr1.to_i(:network) | cidr1.to_i(:hostmask)) )
-        # cidr1 contains cidr2
-        comparasin = 1
-
-    elsif( (cidr2.to_i(:network) | cidr2.to_i(:hostmask)) == (cidr1.to_i(:network) | cidr2.to_i(:hostmask)) )
-        # cidr2 contains cidr1
-        comparasin = -1
-    end
-
-    return(comparasin)
-end
-module_function :cidr_compare
-
-#==============================================================================#
-# cidr_gt_lt()
-#==============================================================================#
-
-# given a pair of CIDRs, determine if first is greater than or less than the second
-#
-# return 1 if cidr1 > cidr2
-# return 0 if cidr1 == cidr2
-# return -1 if cidr1 < cidr2
-#
-def cidr_gt_lt(cidr1,cidr2)
-    gt_lt = 1
-    if(cidr1.to_i(:network) < cidr2.to_i(:network))
-        gt_lt = -1
-    elsif (cidr1.to_i(:network) == cidr2.to_i(:network))
-        if (cidr1.to_i(:netmask) < cidr2.to_i(:netmask))
-            gt_lt = -1
-        elsif (cidr1.to_i(:netmask) == cidr2.to_i(:netmask))
-            gt_lt = 0
-        end
-    end
-
-    return(gt_lt)
-end
-module_function :cidr_gt_lt
-
-#==============================================================================#
-# cidr_fill_in()
-#==============================================================================#
-
-#Given a list of subnets of supernet, return a new list with any
-#holes (missing subnets) filled in.
-#
-def cidr_fill_in(supernet,list)
-        # sort our cidr's and see what is missing
-        complete_list = []
-        expected = supernet.to_i(:network)
-        all_f = supernet.all_f
-
-        NetAddr.cidr_sort(list).each do |cidr|
-            network = cidr.to_i(:network)
-            bitstep = (all_f + 1) - cidr.to_i(:netmask)
-
-            if (network > expected) # missing space at beginning of supernet, so fill in the hole
-                num_ips_missing = network - expected
-                sub_list = cidr_make_subnets_from_base_and_ip_count(supernet,expected,num_ips_missing)
-                complete_list.concat(sub_list)
-            elsif (network < expected)
-                next
-            end
-
-            complete_list.push(cidr)
-            expected = network + bitstep
-        end
-
-        # if expected is not the next subnet, then we're missing subnets
-        # at the end of the cidr
-        next_sub = supernet.next_subnet(:Objectify => true).to_i(:network)
-        if (expected != next_sub)
-            num_ips_missing = next_sub - expected
-            sub_list = cidr_make_subnets_from_base_and_ip_count(supernet,expected,num_ips_missing)
-            complete_list.concat(sub_list)
-        end
-
-        return(complete_list)
-end
-module_function :cidr_fill_in
-
-#==============================================================================#
-# cidr_find_in_list()
-#==============================================================================#
-
-# evaluate cidr against list of cidrs.
-#
-# return entry from list if entry is supernet of cidr (first matching entry)
-# return index # of entry if entry is a duplicate of cidr
-# return nil if no match found
-#
-def cidr_find_in_list(cidr,list)
-    return(nil) if (list.length == 0)
-
-    match = nil
-    low = 0
-    high = list.length - 1
-    index = low + ( (high-low)/2 )
-    while ( low <= high)
-        cmp = cidr_gt_lt(cidr,list[index])
-        if ( cmp == -1 )
-            high = index - 1
-
-        elsif ( cmp == 1 )
-            if (cidr_compare(cidr,list[index]) == -1)
-                match = list[index]
-                break
-            end
-            low = index + 1
-
-        else
-            match = index
-            break
-        end
-        index = low + ( (high-low)/2 )
-    end
-    return(match)
-end
-module_function :cidr_find_in_list
-
-#==============================================================================#
-# cidr_make_subnets_from_base_and_ip_count()
-#==============================================================================#
-
-# Make CIDR addresses from a base addr and an number of ip's to encapsulate.
-#
-#===Arguments:
-#   * cidr
-#   * base ip as integer
-#   * number of ip's required
-#
-#===Returns:
-#   * array of NetAddr::CIDR objects
-#
-    def cidr_make_subnets_from_base_and_ip_count(cidr,base_addr,ip_count)
-        list = []
-        until (ip_count == 0)
-            mask = cidr.all_f
-            multiplier = 0
-            bitstep = 0
-            last_addr = base_addr
-            done = false
-            until (done == true)
-                if (bitstep < ip_count && (base_addr & mask == last_addr & mask) )
-                    multiplier += 1
-                elsif (bitstep > ip_count || (base_addr & mask != last_addr & mask) )
-                    multiplier -= 1
-                    done = true
-                else
-                    done = true
-                end
-                bitstep = 2**multiplier
-                mask = cidr.all_f << multiplier & cidr.all_f
-                last_addr = base_addr + bitstep - 1
-            end
-
-            list.push(NetAddr.cidr_build(cidr.version,base_addr,mask))
-            ip_count -= bitstep
-            base_addr += bitstep
-        end
-
-        return(list)
-    end
-module_function :cidr_make_subnets_from_base_and_ip_count
-
-#==============================================================================#
-# cidr_sort()
-#==============================================================================#
-
-# given a list of NetAddr::CIDRs, return them as a sorted list
-#
-def cidr_sort(list, desc=false)
-    # uses simple quicksort algorithm
-    sorted_list = []
-    if (list.length < 1)
-        sorted_list = list
-    else
-        less_list = []
-        greater_list = []
-        equal_list = []
-        pivot = list[rand(list.length)]
-        if (desc)
-            list.each do |x|
-                if ( pivot.to_i(:network) < x.to_i(:network) )
-                    less_list.push(x)
-                elsif ( pivot.to_i(:network) > x.to_i(:network) )
-                    greater_list.push(x)
-                else
-                    if ( pivot.to_i(:netmask) < x.to_i(:netmask) )
-                        greater_list.push(x)
-                    elsif ( pivot.to_i(:netmask) > x.to_i(:netmask) )
-                        less_list.push(x)
-                    else
-                        equal_list.push(x)
-                    end
-                end
-            end
-        else
-            list.each do |x|
-                gt_lt = cidr_gt_lt(pivot,x)
-                if (gt_lt == 1)
-                    less_list.push(x)
-                elsif (gt_lt == -1)
-                    greater_list.push(x)
-                else
-                    equal_list.push(x)
-                end
-            end
-        end
-
-        sorted_list.concat( cidr_sort(less_list, desc) )
-        sorted_list.concat(equal_list)
-        sorted_list.concat( cidr_sort(greater_list, desc) )
-    end
-
-    return(sorted_list)
-end
-module_function :cidr_sort
-
-#==============================================================================#
-# cidr_summarize()
-#==============================================================================#
-
-# given a list of NetAddr::CIDRs (of the same version) summarize them
-#
-# return a hash, with the key = summary address and val = array of original cidrs
-#
-def cidr_summarize(subnet_list)
-    all_f = subnet_list[0].all_f
-    version = subnet_list[0].version
-    subnet_list = cidr_sort(subnet_list)
-
-    # continue summarization attempts until sorted_list stops getting shorter
-    sorted_list = subnet_list.dup
-    sorted_list_len = sorted_list.length
-    while (1)
-        summarized_list = []
-        until (sorted_list.length == 0)
-            cidr = sorted_list.shift
-            network, netmask = cidr.to_i(:network), cidr.to_i(:netmask)
-            supermask = (netmask << 1) & all_f
-            supernet = supermask & network
-
-            if (network == supernet && sorted_list.length > 0)
-                # network is lower half of supernet, so see if we have the upper half
-                bitstep = (all_f + 1) - netmask
-                expected = network + bitstep
-                next_cidr = sorted_list.shift
-                next_network, next_netmask = next_cidr.to_i(:network), next_cidr.to_i(:netmask)
-
-                if ( (next_network == expected) && (next_netmask == netmask) )
-                    # we do indeed have the upper half. store new supernet.
-                    summarized_list.push( cidr_build(version,supernet,supermask) )
-                else
-                    # we do not have the upper half. put next_cidr back into sorted_list
-                    # and store only the original network
-                    sorted_list.unshift(next_cidr)
-                    summarized_list.push(cidr)
-                end
-            else
-                # network is upper half of supernet, so save original network only
-                summarized_list.push(cidr)
-            end
-
-        end
-
-        sorted_list = summarized_list.dup
-        break if (sorted_list.length == sorted_list_len)
-        sorted_list_len = sorted_list.length
-    end
-
-    # clean up summarized_list
-    unique_list = {}
-    summarized_list.reverse.each do |supernet|
-        next if ( unique_list.has_key?(supernet.desc) )
-        # remove duplicates
-        unique_list[supernet.desc] = supernet
-
-        # remove any summary blocks that are children of other summary blocks
-        index = 0
-        until (index >= summarized_list.length)
-            subnet = summarized_list[index]
-            if (subnet &&  cidr_compare(supernet,subnet) == 1 )
-                unique_list.delete(subnet.desc)
-            end
-            index += 1
-        end
-    end
-    summarized_list = unique_list.values
-
-    # map original blocks to their summaries
-    summarized_list.each do |supernet|
-        supernet.tag[:Subnets] = []
-        index = 0
-        until (index >= subnet_list.length)
-            subnet = subnet_list[index]
-            if (subnet && cidr_compare(supernet,subnet) == 1 )
-                subnet_list[index] = nil
-                supernet.tag[:Subnets].push(subnet)
-            end
-            index += 1
-        end
-    end
-
-    return( NetAddr.cidr_sort(summarized_list) )
-end
-module_function :cidr_summarize
-
-#==============================================================================#
-# cidr_supernets()
-#==============================================================================#
-
-# given a list of NetAddr::CIDRs (of the same version), return only the 'top level' blocks (i.e. blocks not
-# contained by other blocks
-
-def cidr_supernets(subnet_list)
-    summary_list = []
-    subnet_list = netmask_sort(subnet_list)
-    subnet_list.each do |child|
-        is_parent = true
-        summary_list.each do |parent|
-            if (NetAddr.cidr_compare(parent,child) == 1)
-                is_parent = false
-                parent.tag[:Subnets].push(child)
-            end
-        end
-
-        if (is_parent)
-            child.tag[:Subnets] = []
-            summary_list.push(child)
-        end
-    end
-
-    return(summary_list)
-end
-module_function :cidr_supernets
-
-#==============================================================================#
-# netmask_sort()
-#==============================================================================#
-
-# given a list of NetAddr::CIDRs, return them as a sorted (by netmask) list
-#
-def netmask_sort(list, desc=false)
-    # uses simple quicksort algorithm
-    sorted_list = []
-    if (list.length < 1)
-        sorted_list = list
-    else
-        less_list = []
-        greater_list = []
-        equal_list = []
-        pivot = list[rand(list.length)]
-        if (desc)
-            list.each do |x|
-                if ( pivot.to_i(:netmask) < x.to_i(:netmask) )
-                    less_list.push(x)
-                elsif ( pivot.to_i(:netmask) > x.to_i(:netmask) )
-                    greater_list.push(x)
-                else
-                    if ( pivot.to_i(:network) < x.to_i(:network) )
-                        greater_list.push(x)
-                    elsif ( pivot.to_i(:network) > x.to_i(:network) )
-                        less_list.push(x)
-                    else
-                        equal_list.push(x)
-                    end
-                end
-            end
-        else
-            list.each do |x|
-                if ( pivot.to_i(:netmask) < x.to_i(:netmask) )
-                    greater_list.push(x)
-                elsif ( pivot.to_i(:netmask) > x.to_i(:netmask) )
-                    less_list.push(x)
-                else
-                    if ( pivot.to_i(:network) < x.to_i(:network) )
-                        greater_list.push(x)
-                    elsif ( pivot.to_i(:network) > x.to_i(:network) )
-                        less_list.push(x)
-                    else
-                        equal_list.push(x)
-                    end
-                end
-            end
-        end
-
-        sorted_list.concat( netmask_sort(less_list, desc) )
-        sorted_list.concat(equal_list)
-        sorted_list.concat( netmask_sort(greater_list, desc) )
-    end
-
-    return(sorted_list)
-end
-module_function :netmask_sort
-
-end # module NetAddr
-
-__END__

data/lib/eui.rb

@@ -1,463 +0,0 @@
-=begin rdoc
- Copyleft (c) 2006 Dustin Spinhirne
-
- Licensed under the same terms as Ruby, No Warranty is provided.
-=end
-
-module NetAddr
-
-#=EUI - Extended Unique Identifier
-#
-#A class & series of methods for creating and manipulating Extended Unique Identifier
-#(EUI) addresses. Two types of address formats are supported EUI-48 and EUI-64. The 
-#most common use for this class will be to manipulate MAC addresses (which are essentially
-#a type of EUI-48 address).
-#
-#EUI addresses are separated into two parts, the 
-#Organizationally Unique Identifier (OUI) and the Extended Identifier (EI). The OUI
-#is assigned by the IEEE and is used to identify a particular hardware manufacturer.
-#The EI is assigned by the hardware manufacturer as a per device unique address.
-#
-#Probably the most useful feature of this class, and thus the reason it was created,
-#is to help automate certain address assignments within IP. For example, IPv6
-#Link Local addresses use MAC addresses for IP auto-assignment and multicast MAC addresses
-#are determined based on the multicast IP address.
-#
-class EUI
-
-private_class_method :new
-
-#==============================================================================#
-# initialize()
-#==============================================================================#
-
-#===Synopsis
-# 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 EUI objects.
-# Please consider using #create unless you know what you are doing with 100% certainty.
-#
-# Example:
-# NetAddr::EUI48.new('aabbccddeeff')
-#
-#===Arguments:
-#* EUI as a String or Integer. Strings should contain no formatting characters.
-#
-    def initialize(eui)
-
-        if (eui.kind_of?(Integer))
-            @eui_i = eui
-            @eui = eui.to_s(16)
-            if ( self.kind_of?(NetAddr::EUI48) )
-                @eui = '0' * (12 - @eui.length) << @eui if (@eui.length < 12)
-            else
-                @eui = '0' * (16 - @eui.length) << @eui if (@eui.length < 16)
-            end
-
-        elsif(eui.kind_of?(String))
-            @eui = eui
-            @eui_i = eui.to_i(16)
-        else
-            raise ArgumentError, "Expected String or Integer, but #{eui.class} provided."
-        end
-
-        # set ei & oui
-        if ( self.kind_of?(NetAddr::EUI48) )
-            @ei = @eui.slice(6..11)
-        else
-            @ei = @eui.slice(6..15)
-        end
-
-        @oui = @eui.slice(0..5)
-
-    end
-
-#==============================================================================#
-# create()
-#==============================================================================#
-
-#===Synopsis
-#Create a new EUI48 or EUI64 object.
-#
-# Example:
-# addr = NetAddr::EUI.create('aa-bb-cc-dd-ee-ff')
-# addr = NetAddr::EUI.create('aa:bb:cc:dd:ee:ff')
-# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
-# addr = NetAddr::EUI.create('aa-bb-cc-dd-ee-ff-00-01')
-#
-#===Arguments
-#* eui = EUI as a String
-#
-#===Returns
-#* EUI48 or EUI64 object
-#
-    def EUI.create(eui)
-        if (!eui.kind_of? String)
-            raise ArgumentError, "Expected String, but #{eui.class} provided."
-        end
-
-        # validate
-        NetAddr.validate_eui(eui)
-
-        # remove formatting characters
-        eui.gsub!(/[\.\:\-]/, '')
-
-        if (eui.length == 12)
-            eui = NetAddr::EUI48.new(eui)
-        else
-            eui = NetAddr::EUI64.new(eui)
-        end
-
-        return(eui)
-    end
-
-#==============================================================================#
-# address()
-#==============================================================================#
-
-#===Synopsis
-# Returns EUI address. The default address format is xxxx.xxxx.xxxx
-#
-# Example:
-# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
-# addr.address(:Delimiter => '-') => "aa-bb-cc-dd-ee-ff"
-# addr.address(:Delimiter => ':') => "aa:bb:cc:dd:ee:ff"
-#
-#===Arguments:
-#* options = Hash with the following fields:
-#    :Delimiter -- delimitation character. valid values are (- : .)
-#
-#===Returns:
-#* String
-#
-    def address(options=nil)
-        known_args = [:Delimiter]
-        delimiter = '-'
-
-        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?(:Delimiter))
-                delimiter = options[:Delimiter]
-                delimiter = '-' if (delimiter != ':' && delimiter != '.')
-            end
-        end
-
-        if (delimiter == '-' || delimiter == ':')
-            addr = octets.join(delimiter)
-        elsif (delimiter == '.')
-                toggle = 0
-                octets.each do |x|
-                    if (!addr)
-                        addr = x
-                        toggle = 1
-                    elsif (toggle == 0)
-                        addr = addr  << '.' << x
-                        toggle = 1
-                    else
-                        addr = addr << x
-                        toggle = 0
-                    end
-                end
-        end
-
-        return(addr)
-    end
-
-#==============================================================================#
-# ei()
-#==============================================================================#
-
-#===Synopsis
-#Returns Extended Identifier portion of an EUI address (the vendor assigned ID).
-#The default address format is xx-xx-xx
-#
-# Example:
-# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
-# addr.ei(:Delimiter => '-') => "dd-ee-ff"
-#
-#===Arguments:
-#* options = Hash with the following fields:
-#    :Delimiter -- delimitation character. valid values are (-, and :)
-#
-#===Returns:
-#* String
-#
-    def ei(options=nil)
-        known_args = [:Delimiter]
-        delimiter = '-'
-
-        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?(:Delimiter))
-                if (options[:Delimiter] == ':')
-                    delimiter = options[:Delimiter]
-                end
-            end
-        end
-
-        if ( self.kind_of?(NetAddr::EUI48) )
-            ei = octets[3..5].join(delimiter)
-        else
-            ei = octets[3..7].join(delimiter)
-        end
-
-        return(ei)
-    end
-
-#==============================================================================#
-# link_local()
-#==============================================================================#
-
-#===Synopsis
-# Provide an IPv6 Link Local address based on the current EUI address.
-#
-# Example:
-# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
-# addr.link_local() => "fe80:0000:0000:0000:aabb:ccff:fedd:eeff"
-#
-#===Arguments:
-#* options = Hash with the following fields:
-#    :Short -- if true, return IPv6 addresses in short-hand notation
-#    :Objectify -- if true, return CIDR objects
-#
-#===Returns:
-#* CIDR address String or an NetAddr::CIDR object
-#
-    def link_local(options=nil)
-        return( self.to_ipv6('fe80::/64', options) )
-    end
-
-#==============================================================================#
-# oui()
-#==============================================================================#
-
-#===Synopsis
-#Returns Organizationally Unique Identifier portion of an EUI address (the vendor ID).
-#The default address format is xx-xx-xx.
-#
-# Example:
-# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
-# addr.oui(:Delimiter => '-') => "aa-bb-cc"
-#
-#===Arguments:
-#* options = Hash with the following fields:
-#    :Delimiter -- delimitation character. valid values are (-, and :)
-#
-#===Returns:
-#* String
-#
-    def oui(options=nil)
-        known_args = [:Delimiter]
-        delimiter = '-'
-
-        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?(:Delimiter))
-                if (options[:Delimiter] == ':')
-                    delimiter = options[:Delimiter]
-                end
-            end
-        end
-        oui = octets[0..2].join(delimiter)
-
-        return(oui)
-    end
-
-#==============================================================================#
-# to_i()
-#==============================================================================#
-
-#===Synopsis
-#Returns the EUI as an Integer.
-#
-# Example:
-# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
-# addr.to_i => 187723572702975
-#
-#===Arguments:
-#* none
-#
-#===Returns:
-#* Integer
-#
-    def to_i()
-        return(@eui_i)
-    end
-
-#==============================================================================#
-# to_ipv6
-#==============================================================================#
-
-#===Synopsis
-# Given a valid IPv6 subnet, return an IPv6 address based on the current EUI.
-#
-# Example:
-# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
-# addr.to_ipv6('3ffe::/64') => "3ffe:0000:0000:0000:a8bb:ccff:fedd:eeff"
-#
-#===Arguments:
-#* options = Hash with the following fields:
-#    :Short -- if true, return IPv6 addresses in short-hand notation
-#    :Objectify -- if true, return CIDR objects
-#
-#===Returns:
-#* IPv6 address String or an NetAddr::CIDRv6 object
-#
-    def to_ipv6(cidr, options=nil)
-        known_args = [:Short, :Objectify]
-        objectify = false
-        short = false
-
-        if ( !cidr.kind_of?(NetAddr::CIDR) )
-            begin
-                cidr = NetAddr::CIDR.create(cidr)
-            rescue Exception => error
-                raise ArgumentError, "CIDR raised the following errors: #{error}"
-            end
-        elsif (cidr.kind_of?(NetAddr::CIDRv4)  )
-            raise ArgumentError, "Expected CIDRv6, but #{cidr.class} provided."
-        end
-
-        if (cidr.bits > 64)
-            raise ValidationError, "Prefix length of provided CIDR must be /64 or less but was #{cidr.netmask}."
-        end
-
-        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?(:Objectify) && options[:Objectify] == true)
-                objectify = true
-            end
-
-            if (options.has_key?(:Short) && options[:Short] == true)
-                short = true
-            end
-        end
-
-        # get integer equiv of addr. conver eui48 to eui64 if needed
-        if ( self.kind_of?(NetAddr::EUI48) )
-            eui_i = self.to_eui64.to_i
-        else
-            eui_i = self.to_i
-        end
-      
-        # toggle u/l bit
-        eui_i = eui_i ^ 0x0200000000000000
-
-        # create ipv6 address
-        ipv6 = cidr.to_i | eui_i
-
-        if (!objectify)
-            ipv6 = NetAddr.i_to_ip(ipv6, :Version => 6)
-            ipv6 = NetAddr.shorten(ipv6) if (short)
-        else
-            ipv6 = NetAddr::CIDRv6.new(ipv6)
-        end
-
-        return(ipv6)
-    end
-
-#==============================================================================#
-# to_s()
-#==============================================================================#
-
-#===Synopsis
-#Returns the EUI as an unformatted String.
-#
-# Example:
-# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
-# addr.to_s => "aabbccddeeff"
-#
-#===Arguments:
-#* none
-#
-#===Returns:
-#* String
-#
-    def to_s()
-        return(@eui)
-    end
-
-private
-
-#==============================================================================#
-# octets()
-#==============================================================================#
-
-#Returns array with each element representing a single octet of the eui.
-#
-    def octets()
-        return(@octets) if (@octets)
-
-        @octets = []
-        str = ''
-        @eui.each_byte do |chr|
-            str = str << chr
-            if (str.length == 2)
-                @octets.push(str)
-                str = ''
-            end
-        end
-
-        return(@octets)
-    end
-
-end
-
-
-
-# EUI-48 Address - Inherits all methods from NetAddr::EUI. 
-# Addresses of this class have a 24-bit OUI and a 24-bit EI.
-class EUI48 < EUI
-
-    public_class_method :new
-
-#==============================================================================#
-# to_eui64()
-#==============================================================================#
-
-#===Synopsis
-#Return an EUI64 address based on the current EUI48 address.
-#
-# Example:
-# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
-# addr.to_eui64 => NetAddr::EUI64
-#
-#===Arguments:
-#* none
-#
-#===Returns:
-#* NetAddr::EUI64 object
-#
-    def to_eui64()
-        eui = @oui + 'fffe' + @ei
-        return( NetAddr::EUI64.new(eui.to_i(16)) )
-    end
-
-end
-
-
-
-# EUI-64 Address - Inherits all methods from NetAddr::EUI. 
-# Addresses of this class have a 24-bit OUI and a 40-bit EI.
-class EUI64 < EUI
-    public_class_method :new
-end
-
-
-end # module NetAddr
-__END__