calculate network address with perl - perl

Question

How can I get the class c network address from an ipv4 address in perl?
I tried already this:
my $ipObject = new Net::IP("$ip/24");
return $ipObject->prefix();
leads to
Can't call method "prefix" on an undefined value at /usr/share/awstats/plugins/geoipfree.pm line 101, line 1.

Answer 1

Net::IP->new returns undef on error. The error message can be obtained by calling Net::IP::Error().
my $ipObject = Net::IP->new("$ip/24")
or die(Net::IP::Error());
It probably failed because you specified a prefix without using the base address of the subnet. For example, it will fail for 10.1.2.3/24, but not for 10.1.2.0/24.
$ perl -E'
use Net::IP;
Net::IP->new("10.1.2.3/24")
or die(Net::IP::Error());
'
Invalid prefix 00001010000000010000001000000011/24 at -e line 4.
Since you are trying to find the base address of the subnet, it means you'll need to omit the /24 and apply it as a mask to the address. However, I don't see any way of applying a mask to an Net::IP object. In fact, I don't see any way of using Net::IP to obtain the base address of a subnet at all.
On the other hand, it's trivial using NetAddr::IP.
$ perl -E'
use NetAddr::IP;
say NetAddr::IP->new("10.1.2.3/24")->network->addr;
'
10.1.2.0
Of course, you could also use
( my $network = $ip ) =~ s/\.\d+\z/.0/;

Answer 2

ikegami has given you a solution, but I'll point out something. IP addresses are simply base 256 numbers. CIDR involves 'bit masks' which are applied to an IP to differentiate the network address from the host address.
So given an IP of 10.11.12.13 - that's a representation of:
10 * 256 * 256 * 256
+ 11 * 256 * 256
+ 12 * 256
+ 13
Or 168496141
When working with bitmasks, you logically 'and' the mask to get the 'network part'. A /24 is 24 bits (out of 32):
11111111111111111111111100000000
So if you take the IP above, bitwise and to get your network address. A bit like this:
use strict;
use warnings;
my #IP = qw ( 10 11 12 13 );
print join (".", #IP),"\n";
my $DWORD = 0;
foreach my $octet ( #IP ) {
$DWORD *= 256;
$DWORD += $octet;
}
print "Decimal of IP:",$DWORD,"\n";
my $host_mask = 2 ** 8;
my $netmask = 2 ** 32;
$netmask -= $host_mask;
$host_mask -= 1;
printf ( "%032b\n", $netmask);
printf ( "%032b\n", $host_mask);
my $network = $DWORD & $netmask;
my $host = $DWORD & $host_mask;
#and convert back to IP:
my #net;
while ( $network > 0 ) {
my $octet = $network % 256;
$network -= $octet;
$network /= 256;
unshift ( #net, $octet );
}
print "Network part:", join ( ".", #net ),"\n";
my #host_ip;
while ( $host > 0 ) {
my $octet = $host % 256;
$host -= $octet;
$host /= 256;
unshift ( #host_ip, $octet );
}
print "Host Part:", join ( ".", #host_ip ),"\n";
Not particularly complicated, but hopefully illustrates why the 'right' answer is 'use a module' - the conversions back and forth can be error prone.