my @segments = map {
   /^(\d{1,3}\.\d{1,3}\.\d{1,3})/ ? $1 : ()
} keys %hashIPs;
[download]

Note that as far as I can see, this is NOT what you want in your case.

Note also that hashes are unordered, so asking about a sequential order of keys is nonsense: they're always unordered unless you order them explicitly using (for instance) my @ordered = sort keys %hash).

I'm having a hard time understanding what you are trying to do. I think you are trying to list every 24 bit subnet* whose 256 IP addresses are included in a given list of IP addresses (keys %hashIPs). Correct me if I'm wrong.

Since keys %hashIPs can't contain any duplicates, all you have to do is count how many addresses are in each subnet.

For starters, it's much easier to work with IP addresses as numbers so that numerical operators can be used. It's also easy to work on them in packed form, since most numerical operators will also work on those.

use strict;
use warnings;

sub pack_ipv4 {
   my $dotted_ip = @_ ? $_[0] : $_;
   return pack('C4', split(/\./, $dotted_ip));
}

sub unpack_ipv4 {
   my $packed_ip = @_ ? $_[0] : $_;
   return join('.', unpack('C4', $packed_ip));
}

sub get_subnet {
   my ($packed_ip, $subnet_size) = @_;
   my $packed_mask = pack('B32', ('1' x $subnet_size) . ('0' x (32-$su
+bnet_size)));
   return $packed_ip & $packed_mask;
}

my %hashIPs = map { $_ => 1 } (
  (map { "10.0.0.$_" } 0..255),
  (map { "10.0.1.$_" } 0..254),
  (map { "10.0.2.$_" } 0..255),
);

my %count;
for (keys %hashIPs) {
   ++$count{get_subnet(pack_ipv4($_), 24)};
}

for (grep { $count{$_} == 256 } keys %count) {
   print(unpack_ipv4($_), "/24\n");
}
[download]

The bottom bit could also be written as

my %count;
print("$_/24\n")
   for map unpack_ipv4,
       grep ++$count{$_} == 256,
       map get_subnet($_, 24),
       map pack_ipv4,
       keys %hashIPs;
[download]

* — There's really no such thing as subnet classes anymore. What used to be a "Class C subnet" is now a "24 bit subnet" or "subnet with mask 255.255.255.0". You're doing yourself a disservice by thinking in terms of classes.

hth,
PooLpi

Took me a while to realize that idiom's from Regexp::Common::net. I'm not normally a big fan of advocating non-core modules should be in the core, but I would vote for including Regexp::Common.

-derby

my %class_c;
for my $ip (keys %IPs) {
    my $class_c = get_class_c_from_ip($ip);
    my $integer = convert_quad_ip_to_int($ip);
    my $bit = $integer - first_integer_in_class_c($class_c);
    vec($class_c{$class_c}, $bit, 1) = 1;
}
for $network (keys %class_c) {
    print "$network\n" if all_bits_are_1($class_c{$network});
}
[download]

Sorry it doesn't imply map and sorry I left out all the interesting subs but it is often important to lay out the structure of a solution first. You can then ensure that you can make it work and refactor later.

The only thing I can think of is have 255 if statements

Set a state variable to 1. Use a foreach. Construct the IP address. If it's not valid, set the state to 0 and exit the loop.

use Socket qw(inet_aton);

my $start = inet_aton('192.168.1.0');
my $end   = inet_aton('192.168.1.255');

my @ips_in_range = grep { my $n = inet_aton($_); $n ge $start and $n l
+e $end } @ips;
[download]

Maybe...sort all ips by inet_aton order uniquely into an array. For all ips that end in ".0", see if the ip 255 slots down in the array is the same but ending in ".255" (then you know you have 0-255).

The NetAddr::IP module contains several functions that can help:

• $me->contains($other)
  Returns true when $me completely contains $other. False is returned otherwise and undef is returned if $me and $other are not both NetAddr::IP objects.
• ->network()
  Returns a new object refering to the network address of a given subnet. A network address has all zero bits where the bits of the netmask are zero. Normally this is used to refer to a subnet.
• ->hostenum()
  Returns the list of hosts within a subnet.

Assuming that you want to ensure the hash contains all the IPs with the first 3 octets + 0..255:

die "IPs missing" unless keys %hashIPs == 256;
my $base = each( %hashIPs) =~ s[(\.\d+$)][];
exists $hashIPs{ $base . $_ } or die "Missing IP $base.$_" for 0 .. 25
+5;
[download]

That assumes that there are no strays in the hash, but it's not clear from your description what it might contain.

1. This may be what you want:

   $ perl -le'
   my %hashIPs = qw(
       192.168.1.0  1
       192.168.1.1  1
       192.168.1.2  1
       192.168.1.4  1
       192.168.1.5  1
       192.168.1.6  1
       192.168.1.10  1
       192.168.1.11  1
       192.168.1.12  1
       );
   
   my %check;
   for my $ip ( keys %hashIPs ) {
       next unless $ip =~ /^(\d+\.\d+\.\d+)\.(\d+)$/;
       $check{ $1 } = 0 x 256 unless exists $check{ $1 };
       substr $check{ $1 }, $2, 1, 1;
       }
   
   for my $key ( keys %check ) {
       print "Missing: $key.$-[0] - $key.", $+[0] - 1, "\n"
           while $check{ $key } =~ /(?<=1)0+(?=1)|^0+|0+$/g;
       }
   
   '
   Missing: 192.168.1.3 - 192.168.1.3
   Missing: 192.168.1.7 - 192.168.1.9
   Missing: 192.168.1.13 - 192.168.1.255
   [download]

2. Instead of using grep:

   my @segments = grep {/^(\d{1,3}\.\d{1,3}\.\d{1,3})/} keys %hashIPs;
   [download]

   You need to use map:

   my @segments = map /^(\d{1,3}\.\d{1,3}\.\d{1,3})/, keys %hashIPs;
   [download]

my %hashSeg;

for my $ip (sort keys %hashIPs) {
    if ($ip =~ /(\d{1,3}\.\d{1,3}\.\d{1,3})\.\d{1,3}/){
        my $seg = $1;
        $hashSeg{$seg}++;
    } 
}

for my $seg (keys %hashSeg){ 
  if ($hashSeg{$seg} ne '255'){
    print "$seg is not a full \/24\n"; 
  }
  else {
   print "$seg is a full \/24\n";
  } 
}
[download]

ne '255' should be != 255. Shouldn't that be 256 anyway? (0..255 is 256 numbers.)

A standard Class C network consists of 256 addresses (0 to 255 inclusive), of which one is the network address (.0) and the other is the network broadcast address (.255). Although there are exceptions you can't really use .0 or .255 so there are really only 254 useable addresses.

As a policy I would use < 255 myself as would deal with edge cases where ips are repeated more than once. I have some trial software that amuses me with it's message that it expires in -119 days. Clearly they coded an == rather than a < 0.

To make this stype of solution reliable you need a pre-filter to exclude duplicate ips from the list as our logic requires that they must be unique. In this case the OP is using that so all will be well.