On the other hand, who says we have to use native numbers!

use strict;
use warnings;

use Array::IntSpan qw( );
use Math::BigInt   qw( );
use Socket         qw( AF_INET6 inet_pton );

sub ip6_to_num {
   return Math::BigInt->new(
      '0x' . unpack 'H32', inet_pton AF_INET6, $_[0]
   );
}

my $span = Array::IntSpan->new(
   [
      ip6_to_num('2001:0db8:85a3:0000:0000:0000:0000:0000'),
      ip6_to_num('2001:0db8:85a3:ffff:ffff:ffff:ffff:ffff'),
      'Some Network',
   ]
);

for my $addr (qw(
   2001:db8:85a3::8a2e:370:7334
   2001:dc8:85a3::8a2e:370:7334
)) {
   my $network = $span->lookup(ip6_to_num($addr));
   printf("Address %s is %s\n",
      $addr,
      $network ? "present in $network" : 'absent',
   );
}
[download]

Address 2001:db8:85a3::8a2e:370:7334 is present in Some Network
Address 2001:dc8:85a3::8a2e:370:7334 is absent
[download]

I like this as a quick way to get something working, but I think I may ultimately need to go with your first suggestion and change the operators. I already have IP addresses as 4/16 byte entities so changing the operators will save [un]pack calls for each lookup.

Thanks,
-Andrew

If you want to use strings for IP addresses, bitwise string operators may be of help if you need to mask out the subnet with the netmask value for the range.

• Will you be keeping track of seemingly random addresses and ranges, or a list of networks with known netmasks? (e.g. ones associated with your organization)
• How many entries are we talking about; a few, thousands or millions?
• Will the database be used mostly for searches/lookups or will there be a lot of insert/delete operations?
• Will you be using range exceptions such as "A..Z except P-Q"?

The address will probably have some order, but may not have a known netmask.

Probably less than 100's of entries per set.

This will be overwhelmingly for lookups very few insert/delete operations. There will likely be 1000s of lookups per second.

At present exceptions like your example would simply be two ranges A..O and R..Z.

-Andrew

You want Net::CIDR, specifically the cidrlookup function. Pass it an address and a (list of) CIDR blocks and it'll tell you whether the address is in any of the blocks.

If your address range doesn't match a single CIDR block, (eg it's 192.168.32.45 to 192.168.255.255) then you can use the range2cidr function to generate the appropriate list of CIDR blocks.

It should work for both IPv4 and IPv6.