SYNOPSIS
use Net::CIDR;
use Net::CIDR ':all';
print join("\n",
Net::CIDR::range2cidr("192.68.0.0-192.68.255.255",
"10.0.0.0-10.3.255.255"))
. "\n";
#
# Output from above:
#
# 192.68.0.0/16
# 10.0.0.0/14
print join("\n",
Net::CIDR::range2cidr(
"dead:beef::-dead:beef:ffff:ffff:ffff:ffff:ffff:ffff"))
. "\n";
#
# Output from above:
#
# dead:beef::/32
print join("\n",
Net::CIDR::range2cidr("192.68.1.0-192.68.2.255"))
. "\n";
#
# Output from above:
#
# 192.68.1.0/24
# 192.68.2.0/24
print join("\n", Net::CIDR::cidr2range("192.68.0.0/16")) . "\n";
#
# Output from above:
#
# 192.68.0.0-192.68.255.255
print join("\n", Net::CIDR::cidr2range("dead::beef::/46")) . "\n";
#
# Output from above:
#
# dead:beef::-dead:beef:3:ffff:ffff:ffff:ffff:ffff
@list=("192.68.0.0/24");
@list=Net::CIDR::cidradd("192.68.1.0-192.68.1.255", @list);
print join("\n", @list) . "\n";
#
# Output from above:
#
# 192.68.0.0/23
print join("\n", Net::CIDR::cidr2octets("192.68.0.0/22")) . "\n";
#
# Output from above:
#
# 192.68.0
# 192.68.1
# 192.68.2
# 192.68.3
print join("\n", Net::CIDR::cidr2octets("dead::beef::/46")) . "\n";
#
# Output from above:
#
# dead:beef:0000
# dead:beef:0001
# dead:beef:0002
# dead:beef:0003
@list=("192.68.0.0/24");
print Net::CIDR::cidrlookup("192.68.0.12", @list);
#
# Output from above:
#
# 1
@list = Net::CIDR::addr2cidr("192.68.0.31");
print join("\n", @list);
#
# Output from above:
#
# 192.68.0.31/32
# 192.68.0.30/31
# 192.68.0.28/30
# 192.68.0.24/29
# 192.68.0.16/28
# 192.68.0.0/27
# 192.68.0.0/26
# 192.68.0.0/25
# 192.68.0.0/24
# 192.68.0.0/23
# [and so on]
print Net::CIDR::addrandmask2cidr("195.149.50.61", "255.255.255.248")."\n";
#
# Output from above:
#
# 195.149.50.56/29
DESCRIPTION
The Net::CIDR package contains functions that manipulate lists of IP netblocks expressed in CIDR notation. The Net::CIDR functions handle both IPv4 and IPv6 addresses.@cidr_list=Net::CIDR::range2cidr(@range_list);
Each element in the @range_list is a string ``start-finish'', where ``start'' is the first IP address and ``finish'' is the last IP address. range2cidr() converts each range into an equivalent CIDR netblock. It returns a list of netblocks except in the case where it is given only one parameter and is called in scalar context.For example:
@a=Net::CIDR::range2cidr("192.68.0.0-192.68.255.255");
The result is a one-element array, with $a[0] being ``192.68.0.0/16''. range2cidr() processes each ``start-finish'' element in @range_list separately. But if invoked like so:
$a=Net::CIDR::range2cidr("192.68.0.0-192.68.255.255");
The result is a scalar ``192.68.0.0/16''.
Where each element cannot be expressed as a single CIDR netblock range2cidr() will generate as many CIDR netblocks as are necessary to cover the full range of IP addresses. Example:
@a=Net::CIDR::range2cidr("192.68.1.0-192.68.2.255");
The result is a two element array: (``192.68.1.0/24'',``192.68.2.0/24'');
@a=Net::CIDR::range2cidr( "d08c:43::-d08c:43:ffff:ffff:ffff:ffff:ffff:ffff");
The result is an one element array: (``d08c:43::/32'') that reflects this IPv6 netblock in CIDR notation.
range2cidr() does not merge adjacent or overlapping netblocks in @range_list.
@range_list=Net::CIDR::cidr2range(@cidr_list);
The cidr2range() functions converts a netblock list in CIDR notation to a list of ``start-finish'' IP address ranges:
@a=Net::CIDR::cidr2range("10.0.0.0/14", "192.68.0.0/24");
The result is a two-element array: (``10.0.0.0-10.3.255.255'', ``192.68.0.0-192.68.0.255'').
@a=Net::CIDR::cidr2range("d08c:43::/32");
The result is a one-element array: (``d08c:43::-d08c:43:ffff:ffff:ffff:ffff:ffff:ffff'').
cidr2range() does not merge adjacent or overlapping netblocks in @cidr_list.
@netblock_list = Net::CIDR::addr2cidr($address);
The addr2cidr function takes an IP address and returns a list of all the CIDR netblocks it might belong to:
@a=Net::CIDR::addr2cidr('192.68.0.31');
The result is a thirtythree-element array:
('192.68.0.31/32', '192.68.0.30/31', '192.68.0.28/30', '192.68.0.24/29',
[and so on])
consisting of all the possible subnets containing this address from
0.0.0.0/0 to address/32.
Any addresses supplied to addr2cidr after the first will be ignored. It works similarly for IPv6 addresses, returning a list of one hundred and twenty nine elements.
$cidr=Net::CIDR::addrandmask2cidr($address, $netmask);
The addrandmask2cidr function takes an IP address and a netmask, and returns the CIDR range whose size fits the netmask and which contains the address. It is an error to supply one parameter in IPv4-ish format and the other in IPv6-ish format, and it is an error to supply a netmask which does not consist solely of 1 bits followed by 0 bits. For example, '255.255.248.192' is an invalid netmask, as is '255.255.255.32' because both contain 0 bits in between 1 bits.Technically speaking both of those *are* valid netmasks, but a) you'd have to be insane to use them, and b) there's no corresponding CIDR range.
@octet_list=Net::CIDR::cidr2octets(@cidr_list);
cidr2octets() takes @cidr_list and returns a list of leading octets representing those netblocks. Example:
@octet_list=Net::CIDR::cidr2octets("10.0.0.0/14", "192.68.0.0/24");
The result is the following five-element array: (``10.0'', ``10.1'', ``10.2'', ``10.3'', ``192.68.0'').
For IPv6 addresses, the hexadecimal words in the resulting list are zero-padded:
@octet_list=Net::CIDR::cidr2octets("::dead:beef:0:0/110");
The result is a four-element array: (``0000:0000:0000:0000:dead:beef:0000'', ``0000:0000:0000:0000:dead:beef:0001'', ``0000:0000:0000:0000:dead:beef:0002'', ``0000:0000:0000:0000:dead:beef:0003''). Prefixes of IPv6 CIDR blocks should be even multiples of 16 bits, otherwise they can potentially expand out to a 32,768-element array, each!
@cidr_list=Net::CIDR::cidradd($block, @cidr_list);
The cidradd() functions allows a CIDR list to be built one CIDR netblock at a time, merging adjacent and overlapping ranges. $block is a single netblock, expressed as either ``start-finish'', or ``address/prefix''. Example:
@cidr_list=Net::CIDR::range2cidr("192.68.0.0-192.68.0.255"); @cidr_list=Net::CIDR::cidradd("10.0.0.0/8", @cidr_list); @cidr_list=Net::CIDR::cidradd("192.68.1.0-192.68.1.255", @cidr_list);
The result is a two-element array: (``10.0.0.0/8'', ``192.68.0.0/23''). IPv6 addresses are handled in an analogous fashion.
$found=Net::CIDR::cidrlookup($ip, @cidr_list);
Search for $ip in @cidr_list. $ip can be a single IP address, or a netblock in CIDR or start-finish notation. lookup() returns 1 if $ip overlaps any netblock in @cidr_list, 0 if not.$ip=Net::CIDR::cidrvalidate($ip);
Validate whether $ip is a valid IPv4 or IPv6 address, or a CIDR. Returns its argument or undef. Spaces are removed, and IPv6 hexadecimal address are converted to lowercase.$ip with less than four octets gets filled out with additional octets, and the modified value gets returned. This turns ``192.168/16'' into a proper ``192.168.0.0/16''.
If $ip contains a ``/'', it must be a valid CIDR, otherwise it must be a valid IPv4 or an IPv6 address.
A technically invalid CIDR, such as ``192.168.0.1/24'' fails validation, returning undef.
BUGS
Garbage in, garbage out. Always use cidrvalidate() before doing anything with untrusted input. Otherwise, ``slightly'' invalid input will work (extraneous whitespace is generally OK), but the functions will croak if you're totally off the wall.AUTHOR
Sam Varshavchik <[email protected]>With some contributions from David Cantrell <[email protected]>