use Socket;
my @ip = qw( 10.0.4.100 10.0.4.99 10.3.5.21 10.0.4.101 10.15.21.6);

@ip = do {
    my $prev;
    map { defined($prev) && $prev == $_ ? () : ( $prev = $_ ) }
      sort { $a <=> $b }
      map { unpack "N", inet_aton $_ } @ip;
};
for my $i ( 0 .. $#ip ) {
    if (!$i || $i == $#ip ||
         $ip[$i-1] != $ip[$i] - 1 ||
         $ip[$i+1] != $ip[$i] + 1 )
    {
        print $ip[$i-1] == $ip[$i] - 1 ? "-" : " " if $i;
        print inet_ntoa( pack "N", $ip[$i] );
    }
}
print "\n";
[download]

• Net::CIDR
• Net::CIDR::Lite
• Net::Netmask
• Tie::NetAddr::IP
• Net::IP
• Net::IP::Match
• Net::ACL
• Net::IPv4Addr
• Network::IPv4Addr
• NetAddr::IP
• Net::IP::Match
• NetAddr::IP::Count
• Net::Subnet::Count
• CIDR::Assign

Update: Fwiw, I found these modules through http://search.cpan.org using these terms: netmask, subnet, ip address, and cidr.

Update II: Anonymonk provides below what was beginning to percolate into my brain - that is, convert the dotted quad addresses to their (real) binary values, then sort and look for sequential blocks.   ++anonymonk.

The sorting part is easy:

  @sortedip = map {
    "$$_[0].$$_[1].$$_[2]$$_[3]"
  } sort {
    ($$a[0] <=> $$b[0]) or
    ($$a[1] <=> $$b[1]) or
    ($$a[2] <=> $$b[2]) or
    ($$a[3] <=> $$b[3])
  } map {
    /(\d+)[.](\d+)[.](\d+)[.](\d+)/;
    [$1, $2, $3, $4]
  } @ip;
[download]

Personally I would leave off that (typographically) first map, so that you get a list of arrayrefs; the range checking will probably be easier that way. Speaking of the range checking... you probably want to use a foreach loop over the now sorted list, in each case keeping track of the previous IP or range and pushing that if the current IP isn't contiguous. Something along these lines...

  @sorted = sort {
    ($$a[0] <=> $$b[0]) or
    ($$a[1] <=> $$b[1]) or
    ($$a[2] <=> $$b[2]) or
    ($$a[3] <=> $$b[3])
  } map {
    /(\d+)[.](\d+)[.](\d+)[.](\d+)/;
    [$1, $2, $3, $4]
  } @ip;
  my $previous = []; my @range = ();
  for $current (@sorted, [260, 0, 0, 0]) {
     if (greaterbyone($previous,$current) {
        $$previous[4] = $$current[3];
     } else {
        push @range, $previous;
        $previous = $current;
  }
[download]

greaterbyone just has to return true if the IP address in its second argument is one greater than the IP address or range in its first argument. I'll leave that part as an exercise.

$;=sub{$/};@;=map{my($a,$b)=($_,$;);$;=sub{$a.$b->()}}
split//,".rekcah lreP rehtona tsuJ";$\=$ ;->();print$/
[download]

from NetAddr::IP tutorial...

Optimising the address space

This is one of the reason for writing NetAddr::IP in the first place. Let's say you have a few chunks of IP space and you want to find the optimum CIDR representation for them. By optimum, I mean the least amount of CIDR subnets that exactly represent the given IP address space. The code below is an example of this:

use NetAddr::IP;

push @addresses, NetAddr::IP->new($_) for <DATA>;
print join(", ", NetAddr::IP::compact(@addresses)), "\n";
__DATA__
10.0.0.0/18
10.0.64.0/18
10.0.192.0/18
10.0.160.0/19

Which will, of course, output 10.0.0.0/17, 10.0.160.0/19, 10.0.192.0/18.

and also in the tutorial is enough to print those combined ranges in just about any format you can come up with.

If there is a better solution that uses established modules, I would suggest that. Barring that, here is some code I was toying with a while back to do something similar-probably not the best or most efficient way to do it, however. (Address data was in __DATA__, which I did not include here for length.) Hope maybe this might give you an idea or two (if nothing else, maybe of how not to do it).

my @IP=qw(10.0.4.100 10.0.4.99 10.3.5.21 10.0.4.101 10.15.21.6);

my @sorted_IP=map{substr($_,4) }
              sort
              map{pack('C4',/(\d+)\.(\d+)\.(\d+)\.(\d+)/).$_}@IP;
[download]