Net::Netmask

DESCRIPTION
Net::Netmask parses and understands IPv4 CIDR blocks. It's built with an object-oriented interface. Nearly all functions are methods that operate on a Net::Netmask object. There are methods that provide the nearly all bits of information about a network block that you might want. There are also functions to put a network block into a table and then later lookup network blocks by IP address in that table. There are functions to turn a IP address range into a list of CIDR blocks. There are functions to turn a list of CIDR blocks into a list of IP addresses. There is a function for sorting by text IP address.

use strict;
use Net::IP;
my $net = new Net::IP("10.4.5.0/24");
my $host = new Net::IP("10.4.5.1");
print "yes\n" if ($net->overlaps($host) == $Net::IP::IP_B_IN_A_OVERLAP
+);
[download]

HTH, --traveler

Other than the proposed module solutions, why do you even need a regex?

sub in_range {
  my( $number, $low, $high ) = @_;

  return 1 if $number >= $low && $number <= $high;
  return 0;
}

my $match = in_range( 68 => 128, 255 );
[download]

    --k.

$match = 0;
$ip = $ARGV[0] ? $ARGV[0] : "129.10.10.120";
($a,$b,$c,$d) = split '\.', $ip;

$match = 1 if ($a > 127 && $a < 256);
print "$match\n";
[download]

Is there an easy way to match a range of numbers like 128-255?

An assertion is a regex pattern that must match, but which doesn't eat any characters. Well known assertions are anchoring (/^/ and /$/), edge matching (/\b/) and lookahead and lookbehind (eh... see perlre).

So how can you do assertion in Perl code? The following solution is based on work by dominus: using the experimental feature of embedding code in a regex, /(?{CODE})/, and use the result of that code as a condition in another experimental feature, conditional matches: /(?(condition)yes-pattern)/ or /(?(condition)yes-pattern|no-pattern)/. A third trick is to use a pattern that can never match: since // always matches, its negation (using negative lookahead), /(?!)/, will always fail.

The combination, which acts like an assertion in Perl code, can look like

(?(?{NOT-COND})(?!))
[download]

(?(?{COND})|(?!))
[download]

/\b(\d+)\b(?(?{not($1 >= 128 && $1 <= 255)})(?!))/
[download]

/\b(\d+)\b(?(?{$1 >= 128 && $1 <= 255})|(?!))/
[download]

In case you're wondering about the /\b/ assertions: in case our assertion in code fails, it will not prevent backtracking. So without them, if the assertion fails for "350", it would backtrack and try again using "35", and succeed there. That is not what you want, here. Or, with just a trailing /\b/ as in /\d+\b/, it could still succeed for "50". That's why you need both.

Try out NetAddr::IP. It parses the input subnet specification. Then you can use the ->contains function to look for what you want. It also has a variety of other uses.

Best regards

-lem, but some call me fokat

If you want to avoid the overhead of a full module, you could probably to it with two functions. First, something to convert IP addresses into integers, like:

sub ip_2_int {
    my ($ip) = @_;
    $ip =~ /(\d+)\.(\d+)\.(\d+)\.(\d+)/
         or die "$ip is an invalid address";
    return ($1<<24)|($2<<16)|($3<<8)|$4;
}
[download]

Then, you just want to compare the network parts of the IP address with the network address. So, obviously you need to create the netmask (i.e., /16 is (2**16)-1, I think?), and then just compare the numbers, i.e.:

if (($ipaddress|$netmask)==$network) {
    # then $ipaddress is in the range $network/$netmask defines
}
[download]

You could obviously wrap that in a common function, perhaps something like:

sub isInNetwork {
    my ($cidr_str, $ipaddress_str) = @_;
    my ($network_str, $netmask_str) = split ('/', $cidr_str);
    my ($network, $ip) = (ip_2_int ($network_str), 
        ip_2_int ($ipaddress_str));
    return ($network==($ip|(2**$network-1));
}

print "10.0.50.12 is in 10/8!\n"
    if isInNetwork ('10.0.0.0/8', '10.0.50.12');
[download]

Or something (much more error checking would of course be required ;). That's off the bat, unfortunately I don't have access to a Perl right now :/ But, I'm pretty sure it's not supposed to be sufficiently complex to require a regex - remember, C programmers use IP addresses (socket.h), so it's can't be very difficult.