Class: NetAddr::CIDRv4

Inherits:

CIDR

• Object
• CIDR
• NetAddr::CIDRv4

Defined in:

lib/cidr.rb

Overview

IPv4 CIDR address - Inherits all methods from NetAddr::CIDR. Addresses of this class are composed of a 32-bit address space.

Instance Attribute Summary

Attributes inherited from CIDR

#all_f, #tag, #version

Instance Method Summary

• #hostmask_ext ⇒ Object

  Synopsis Provide IPv4 Hostmask in extended format (y.y.y.y).

• #initialize(addr, options = nil) ⇒ CIDRv4 constructor

  Synopsis Return a CIDRv4 object.

• #netmask_ext ⇒ Object

  Synopsis Provide IPv4 netmask in extended format (y.y.y.y).

Methods inherited from CIDR

#arpa, #bits, #cmp, #contains?, create, #desc, #enumerate, #eql?, #fill_in, #ip, #is_contained?, #last, #matches?, #multicast_mac, #netmask, #network, #next_ip, #next_subnet, #nth, #packed_hostmask, #packed_ip, #packed_netmask, #packed_network, #packed_wildcard_mask, #range, #remainder, #resize, #resize!, #size, #subnet, #wildcard_mask

Constructor Details

#initialize(addr, options = nil) ⇒ CIDRv4

Synopsis

Return a CIDRv4 object. CIDR formatted netmasks take precedence over extended formatted ones. CIDR address defaults to a host network (/32) if netmask not provided. :PackedNetmask takes precedence over netmask given within CIDR address.

cidr4 = NetAddr::CIDRv4.new(‘192.168.1.1/24’) cidr4 = NetAddr::CIDRv4.new(‘192.168.1.1 255.255.255.0’) cidr4_2 = NetAddr::CIDRv4.new(0x0a010001,

:PackedNetmask => 0xffffff00)

cidr4_3 = NetAddr::CIDRv4.new(‘192.168.1.1’,

:WildcardMask => ['0.7.0.255', :inversed])

cidr4_4 = NetAddr::CIDRv4.new(‘192.168.5.0’,

:WildcardMask => ['255.248.255.0'])

cidr4_5 = NetAddr::CIDRv4.new(‘192.168.1.1’,

:WildcardMask => 0x000700ff)

Arguments:

• CIDR address as a String, or a packed IP address as an Integer

• Optional Hash with the following keys:

  :PackedNetmask -- Integer representation of an IP Netmask (optional)
  :Tag -- Custom descriptor tag - Hash, tag => value. (optional)
  :WildcardMask -- 2 element Array. First element contains a special bit mask used for
                   advanced IP pattern matching. The second element should be :inversed if this
                   bit mask is in inverse format. (optional)
  

# File 'lib/cidr.rb', line 1806

def initialize(addr, options=nil)
    known_args = [:PackedNetmask, :Tag, :WildcardMask]
    @tag = {}
    @version = 4
    @max_bits = 32
    @all_f = 2**@max_bits - 1
    
    # validate addr arg
    if (addr.kind_of?(String))
        cidr = addr
    elsif (addr.kind_of?(Integer))
        packed_ip = addr
    else
        raise ArgumentError, "String or Integer expected for argument 'addr' but #{addr.class} provided."
    end
    
    # validate options
    if (options)     
        raise ArgumentError, "Hash expected for argument 'options' but " +
                             "#{options.class} provided." if (!options.kind_of?(Hash) )
        NetAddr.validate_args(options.keys,known_args)
        
        if (options.has_key?(:PackedNetmask))
            packed_netmask = options[:PackedNetmask]
            raise ArgumentError, "Expected Integer, but #{packed_netmask.class} " +
                                 "provided for option :PackedNetmask." if (!packed_netmask.kind_of?(Integer))
        end

        if (options.has_key?(:Tag))
            @tag = options[:Tag]
            if (!@tag.kind_of? Hash)
                raise ArgumentError, "Expected Hash, but #{@tag.class} provided for option :Tag."
            end
        end

        if (options.has_key?(:WildcardMask))
            if (!options[:WildcardMask].kind_of?(Array))
                raise ArgumentError, "Expected Array, but #{options[:WildcardMask].class} provided for option :WildcardMask."
            end
            wildcardmask = options[:WildcardMask][0]
            inversed = false
            inversed = true if (options[:WildcardMask][1] && options[:WildcardMask][1] == :inversed)

            if (wildcardmask.kind_of?(Integer))
               begin
                    @wildcard_mask = wildcardmask
                    NetAddr.validate_ip_addr(@wildcard_mask, :Version => @version)
                rescue NetAddr::ValidationError
                    raise NetAddr::ValidationError, ":WildcardMask must be a valid IPv#{@version} address."
                end 
            else
                begin
                    @wildcard_mask = NetAddr.pack_ip_addr(wildcardmask, :Version => @version)
                rescue NetAddr::ValidationError
                    raise NetAddr::ValidationError, ":WildcardMask must be a valid IPv#{@version} address."
                end
            end

            @wildcard_mask = @wildcard_mask ^ @all_f if (inversed)
        end
    end


    if (packed_ip)
        # validate & store packed_ip
        NetAddr.validate_ip_addr(packed_ip, :Version => @version)
        @ip = packed_ip
    
    else           
        # if extended netmask provided. should only apply to ipv4            
        if (cidr =~ /.+\s+.+/ )
            cidr,netmask = cidr.split(' ')
        end           
   
        # if netmask part of cidr, then over-ride any provided extended netmask.
        if (cidr =~ /\//) 
            ip,netmask = cidr.split(/\//)
            if (!ip || !netmask)
                raise ArgumentError, "CIDR address is improperly formatted. Missing netmask after '/' character." 
            end
        else
            ip = cidr
        end
        
        # pack ip                
        @ip = NetAddr.pack_ip_addr(ip, :Version => @version)           
    end
    
    # if no netmask or packed_netmask, then set
    # else validate. packed_netmask takes precedence over netmask
    if (!netmask && !packed_netmask)
        @netmask = @all_f
    else            
        if (packed_netmask)
            NetAddr.validate_ip_netmask(packed_netmask, :Packed => true, :Version => @version)
            @netmask = packed_netmask
        else
            NetAddr.validate_ip_netmask(netmask, :Version => @version)
            @netmask = NetAddr.pack_ip_netmask(netmask, :Version => @version)
        end
    end
    
    # set @network & @hostmask
    @network = (@ip & @netmask)
    @hostmask = @netmask ^ @all_f
    @wildcard_mask = @hostmask if (!@wildcard_mask)

end

Instance Method Details

#hostmask_ext ⇒ Object

Synopsis

Provide IPv4 Hostmask in extended format (y.y.y.y).

puts cidr4.hostmask_ext(

Arguments:

• none

Returns:

• String

# File 'lib/cidr.rb', line 1938

def hostmask_ext()
    return(NetAddr.unpack_ip_addr(@hostmask, :Version => @version))
end

#netmask_ext ⇒ Object

Synopsis

Provide IPv4 netmask in extended format (y.y.y.y).

puts cidr4.netmask_ext()

Arguments:

• none

Returns:

• String

# File 'lib/cidr.rb', line 1957

def netmask_ext()    
    return(NetAddr.unpack_ip_addr(@netmask))
end