diff --git a/IP.pm b/IP.pm
index 19a3e7e..3fa8cf9 100644
--- a/IP.pm
+++ b/IP.pm
@@ -1,6 +1,6 @@
#!/usr/bin/perl -w
-# $Id: IP.pm,v 1.11 2003/02/12 00:09:57 lem Exp $
+# $Id: IP.pm,v 1.13 2003/10/09 00:12:21 lem Exp $
package NetAddr::IP;
@@ -35,8 +35,6 @@
Many operators have been overloaded, as described below:
-=over
-
=cut
require 5.005_62;
@@ -50,7 +48,7 @@
our @ISA = qw(Exporter);
-our $VERSION = '3.14_3';
+our $VERSION = '3.15';
#############################################
# These are the overload methods, placed here
@@ -134,6 +132,8 @@
=pod
+=over
+
=item B<Assignment (C<=>)>
Has been optimized to copy one NetAddr::IP object to another very quickly.
@@ -212,14 +212,41 @@
return $ip unless $const;
+ my $b = $ip->{bits};
my $a = $ip->{addr};
my $m = $ip->{mask};
- my $b = $ip->{bits};
-
+
my $hp = "$a" & ~"$m";
my $np = "$a" & "$m";
- vec($hp, 0, $b) += $const;
+ if ($b == 128) # v6?
+ {
+ use Math::BigInt;
+
+ my $num = new Math::BigInt 0;
+
+ for (0 .. 15)
+ {
+ $num <<= 8;
+ $num |= vec($hp, $_, 8);
+ }
+
+# warn "# add - before badd($const): $num\n";
+ $num->badd($const);
+# warn "# add - after badd($const): $num\n";
+
+ for (reverse 0 .. 15)
+ {
+ my $x = new Math::BigInt $num;
+ vec($hp, $_, 8) = $x & 0xFF;
+ $num >>= 8;
+# warn "# add - octet $_ == $num / ", vec($hp, $_, 8), "\n";
+ }
+ }
+ else # v4
+ {
+ vec($hp, 0, $b) += $const;
+ }
return _fnew NetAddr::IP [ "$np" | ("$hp" & ~"$m"), $m, $b];
}
@@ -498,7 +525,17 @@
vec($addr, 2, 8) = ($present ? $3 : 0);
vec($addr, 3, 8) = ($present ? 0 : $3);
}
- elsif ($ip =~ m/^([xb\d]+)$/) {
+ elsif ($ip =~ m/^([xb\d]+)$/ and $1 >= 0 and $1 < 255 and $present)
+ {
+ vec($addr, 0, 8) = $1;
+ vec($addr, 1, 8) = 0;
+ vec($addr, 2, 8) = 0;
+ vec($addr, 3, 8) = 0;
+ }
+ elsif ($ip =~ m/^([xb\d]+)$/)
+ {
+ my $num = $1;
+ $num += 2 ** 32 if $num < 0;
vec($addr, 0, 32) = $1;
}
@@ -1088,6 +1125,8 @@
returned otherwise and C<undef> is returned if C<$me> and C<$other>
are of different versions.
+Note that C<$me> and C<$other> must be C<NetAddr::IP> objects.
+
=cut
sub contains ($$) {
@@ -1122,6 +1161,8 @@
The complement of C<-E<gt>contains()>. Returns true when C<$me> is
completely con tained within C<$other>.
+Note that C<$me> and C<$other> must be C<NetAddr::IP> objects.
+
=cut
sub within ($$) {
@@ -1167,36 +1208,82 @@
if (vec($self->{mask}, 0, $bits)
<= vec($mask, 0, $bits))
{
-
- my $delta = '';
my $num = '';
my $v = '';
- vec($num, 0, $bits) = _ones $bits;
- vec($num, 0, $bits) ^= vec($mask, 0, $bits);
- vec($num, 0, $bits) ++;
-
- vec($delta, 0, $bits) = (vec($self->{mask}, 0, $bits)
- ^ vec($mask, 0, $bits));
-
- my $net = $self->network->{addr};
+ my $net = $self->network->{addr};
$net = "$net" & "$mask";
- my $to = $self->broadcast->{addr};
+ my $to = $self->broadcast->{addr};
$to = "$to" & "$mask";
- # XXX - Note that most likely,
- # this loop will NOT work on IPv6...
- # $net, $to and $num might very well
- # be too large for most integer or
- # floating point representations.
-
- for (my $i = vec($net, 0, $bits);
- $i <= vec($to, 0, $bits);
- $i += vec($num, 0, $bits))
+ if ($bits == 128)
{
- vec($v, 0, $bits) = $i;
- push @ret, $self->_fnew([ $v, $mask, $bits ]);
+ use Math::BigInt;
+
+ my $n = new Math::BigInt 0;
+ my $t = new Math::BigInt 0;
+ my $u = new Math::BigInt 0;
+ my $x = '';
+
+ for (0 .. 15)
+ {
+ vec($num, $_, 8) = _ones 8;
+ vec($num, $_, 8) ^= vec($mask, $_, 8);
+ $n <<= 8;
+ $t <<= 8;
+ $u <<= 8;
+ $n |= vec($net, $_, 8);
+ $t |= vec($to, $_, 8);
+ $u |= vec($num, $_, 8);
+ }
+
+# warn "# splitref $self $mask\n";
+# warn "# net = ", $self->network, "\n";
+# warn "# bro = ", $self->broadcast, "\n";
+
+# warn "# before, n = $n\n";
+# warn "# before, t = $t\n";
+# warn "# before, u = $u\n";
+
+ $u++;
+ my $i = $n->copy;
+
+ do {
+
+ my $j = $i->copy;
+
+# warn "# i = $i\n";
+# warn "# j = $j\n";
+# warn "# n = $n\n";
+# warn "# u = $u\n";
+# warn "# t = $t\n";
+# warn "###\n";
+
+ for (reverse 0 .. 15)
+ {
+ vec($v, $_, 8) = ($j & 0xFF);
+ $j >>= 8;
+ }
+
+ push @ret, $self->_fnew([ $v, $mask, $bits ]);
+# warn "# add ", $self->_fnew([$v, $mask, $bits]), "\n";
+ $i += $u;
+ } while ($i <= $t);
+ }
+ else
+ {
+ vec($num, 0, $bits) = _ones $bits;
+ vec($num, 0, $bits) ^= vec($mask, 0, $bits);
+ vec($num, 0, $bits) ++;
+
+ for (my $i = vec($net, 0, $bits);
+ $i <= vec($to, 0, $bits);
+ $i += vec($num, 0, $bits))
+ {
+ vec($v, 0, $bits) = $i;
+ push @ret, $self->_fnew([ $v, $mask, $bits ]);
+ }
}
}
@@ -1245,6 +1332,8 @@
"correct" approach has been adopted and only one address would be
returned.
+Note that C<$me> and all C<$addr>-n must be C<NetAddr::IP> objects.
+
=cut
sub compact {
@@ -1261,6 +1350,7 @@
reference to a list. Note that this method takes a reference to a list
instead.
+Note that C<$me> must be a C<NetAddr::IP> object.
=cut
sub compactref ($) {
@@ -1402,7 +1492,7 @@
=head1 HISTORY
-$Id: IP.pm,v 1.11 2003/02/12 00:09:57 lem Exp $
+$Id: IP.pm,v 1.13 2003/10/09 00:12:21 lem Exp $
=over
@@ -1928,6 +2018,24 @@
this semantic and make everyone happy, but I won't do anything else
here without (significant) feedback.
+=item 3.14_4
+
+As noted by Michael, 127/8 should be 127.0.0.0/8 and not
+0.0.0.128/8. Also, improved docs on the usage of contains() and
+friends.
+
+=item 3.15
+
+Finally. Added POD tests (and fixed minor doc bug in IP.pm). As
+reported by Anand Vijay, negative numbers are assumed to be signed
+ints and converted accordingly to a v4 address. split() and nth() now
+work with IPv6 addresses (Thanks to Venkata Pingali for
+reporting). Tests were added for v6 base functionality and
+splitting. Also tests for bitwise aritmethic with long integers has
+been added. I'm afraid Math::BigInt is now required.
+
+Note that IPv6 might not be as solid as I would like. Be careful...
+
=back
=head1 AUTHOR
diff --git a/MANIFEST b/MANIFEST
index 4956ca7..a73e201 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -2,10 +2,12 @@
TODO
README
MANIFEST
+MANIFEST.SKIP
Makefile.PL
tutorial.htm
t/00-load.t
t/loops.t
+t/bitops.t
t/v4-new.t
t/v4-num.t
t/relops.t
@@ -34,4 +36,5 @@
t/v4-contains.t
t/v4-hostenum.t
t/v4-split-bulk.t
+t/v6-split-bulk.t
t/v4-split-list.t
diff --git a/MANIFEST.SKIP b/MANIFEST.SKIP
new file mode 100644
index 0000000..e6aa309
--- /dev/null
+++ b/MANIFEST.SKIP
@@ -0,0 +1,17 @@
+^blib/
+^Makefile$
+^Makefile\.[a-z]+$
+^pm_to_blib$
+CVS/.*
+,v$
+^tmp/
+\.old$
+\.bak$
+~$
+^#
+\.shar$
+\.tar$
+\.tgz$
+\.tar\.gz$
+\.zip$
+_uu$
diff --git a/Makefile.PL b/Makefile.PL
index 529e3c6..11da492 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -2,15 +2,42 @@
# See lib/ExtUtils/MakeMaker.pm for details of how to influence
# the contents of the Makefile that is written.
-# $Id: Makefile.PL,v 1.3 2002/12/10 17:14:02 lem Exp $
+# $Id: Makefile.PL,v 1.5 2003/10/09 00:12:22 lem Exp $
+
+my $checker = 0;
+
+eval { use Test::Pod;
+ $checker = 1; };
+
+unless ($checker)
+{
+ print <<EOF;
+
+Looks like this host does not have Test::Pod installed. Without this module,
+the Pod documentation cannot be tested. This is not a big deal really, but
+you might want to install Test::Mod by issuing the following command:
+
+ perl -MCPAN -e "install('Test::Pod')"
+
+at a nearby shell. This is nice because it allows easy tests of your own
+documentation.
+
+EOF
+ ;
+}
WriteMakefile(
'NAME' => 'NetAddr::IP',
'VERSION_FROM' => 'IP.pm', # finds $VERSION
'PREREQ_PM' => {
Test::More => 0,
+ Math::BigInt => 0,
}, # e.g., Module::Name => 1.1
($] >= 5.005 ? ## Add these new keywords supported since 5.005
(ABSTRACT_FROM => 'IP.pm',
AUTHOR => 'Luis E. Mu�oz <luismunoz@cpan.org>') : ()),
);
+
+
+
+
diff --git a/t/00-load.t b/t/00-load.t
index 4b9ed63..4865087 100644
--- a/t/00-load.t
+++ b/t/00-load.t
@@ -1,11 +1,36 @@
+# Generic load/POD test suite
-# Test if the module will load correctly
+# $Id: 00-load.t,v 1.3 2003/10/08 06:46:02 lem Exp $
-# $Id: 00-load.t,v 1.2 2002/10/31 04:30:35 lem Exp $
+use Test::More;
-BEGIN { $| = 1; print "1..1\n"; }
-END {print "not ok 1\n" unless $loaded;}
-use NetAddr::IP;
-$loaded = 1;
-print "ok 1\n";
+my @modules = qw/
+ NetAddr::IP
+ /;
+
+my @paths = ();
+
+plan tests => 2 * scalar @modules;
+
+use_ok($_) for @modules;
+
+my $checker = 0;
+
+eval { use Test::Pod;
+ $checker = 1; };
+
+for my $m (@modules)
+{
+ my $p = $m . ".pm";
+ $p =~ s!::!/!g;
+ push @paths, $INC{$p};
+}
+
+END { unlink "./out.$$" };
+
+SKIP: {
+ skip "Test::Pod is not available on this host", scalar @paths
+ unless $checker;
+ pod_file_ok($_) for @paths;
+}
diff --git a/t/bitops.t b/t/bitops.t
new file mode 100644
index 0000000..4ef4ca8
--- /dev/null
+++ b/t/bitops.t
@@ -0,0 +1,64 @@
+# This code exercises some common functions that are used in parts
+# of v6 management of IP.pm. It is intended as a reference in case
+# of failure
+
+# $Id: bitops.t,v 1.1 2003/10/09 00:14:06 lem Exp $
+
+use Test::More;
+use NetAddr::IP;
+use Math::BigInt;
+
+my @bases = (); # Base set of trivial numbers
+my @convs = (); # Numbers after conversion / de-conversion
+my @minus = (); # Bases minus one
+my @plus = (); # Bases plus one
+
+for my $i (0 .. 127)
+{
+ my $I = new Math::BigInt 1;
+ $I <<= $i;
+ push @bases, $I;
+ $I = new Math::BigInt 3;
+ $I <<= $i;
+ push @bases, $I;
+}
+
+pop @bases;
+
+plan tests => scalar @bases;
+
+ # Test conversion back and forth
+ # to/from a suitable vec()
+
+for my $i (0 .. $#bases) # Build the actual conversion
+{
+ my $v = '';
+ my $I = $bases[$i]->copy;
+
+ for my $j (reverse 0 .. 15)
+ {
+ vec($v, $j, 8) = ($I & 0xFF);
+ $I >>= 8;
+ }
+
+# print "# ";
+# printf "%02x", $_ for map { ord $_ } split //, $v;
+# print "\n";
+
+ push @convs, $v;
+}
+
+for my $i (0 .. $#bases) # Test reversibility
+{
+ my $I = new Math::BigInt 0;
+ for my $o (0 .. 15)
+ {
+ $I <<= 8;
+ $I |= vec($convs[$i], $o, 8);
+# print "I = $I ($o)\n";
+ }
+
+ is($bases[$i], $I, "$bases[$i] == $I [$i]");
+}
+
+
diff --git a/t/relops.t b/t/relops.t
index 69037b9..ae74a2a 100644
--- a/t/relops.t
+++ b/t/relops.t
@@ -1,6 +1,6 @@
use NetAddr::IP;
-# $Id: relops.t,v 1.3 2003/02/12 00:09:58 lem Exp $
+# $Id: relops.t,v 1.4 2003/10/08 06:46:02 lem Exp $
BEGIN {
@gt = (
@@ -31,22 +31,22 @@
use Test::More tests => @gt + @ngt + (2 * @cmp);
for my $a (@gt) {
- my $a_ip = new NetAddr::IP $a->[0];
- my $b_ip = new NetAddr::IP $a->[1];
+ $a_ip = new NetAddr::IP $a->[0];
+ $b_ip = new NetAddr::IP $a->[1];
ok($a_ip > $b_ip, "$a_ip > $b_ip");
}
for my $a (@ngt) {
- my $a_ip = new NetAddr::IP $a->[0];
- my $b_ip = new NetAddr::IP $a->[1];
+ $a_ip = new NetAddr::IP $a->[0];
+ $b_ip = new NetAddr::IP $a->[1];
ok(!($a_ip > $b_ip), "$a_ip !> $b_ip");
}
-for my $a (@cmp) {
- my $a_ip = new NetAddr::IP $a->[0];
- my $b_ip = new NetAddr::IP $a->[1];
+for $a (@cmp) {
+ $a_ip = new NetAddr::IP $a->[0];
+ $b_ip = new NetAddr::IP $a->[1];
is($a_ip <=> $b_ip, $a->[2], "$a_ip <=> $b_ip is $a->[2]");
is($a_ip cmp $b_ip, $a->[2], "$a_ip cmp $b_ip is $a->[2]");
diff --git a/t/v4-new.t b/t/v4-new.t
index e392c31..87e2030 100644
--- a/t/v4-new.t
+++ b/t/v4-new.t
@@ -1,14 +1,16 @@
use NetAddr::IP;
-# $Id: v4-new.t,v 1.5 2002/12/27 20:37:55 lem Exp $
+# $Id: v4-new.t,v 1.7 2003/10/08 06:46:02 lem Exp $
BEGIN {
our @a = (
- [ 'localhost', '127.0.0.1' ],
- [ 0x01010101, '1.1.1.1' ],
- [ 1, '0.0.0.1' ],
- [ 'default', '0.0.0.0' ],
- [ 'any', '0.0.0.0' ],
+ [ 'localhost', '127.0.0.1' ],
+ [ 0x01010101, '1.1.1.1' ],
+ [ 1, '1.0.0.0' ], # Because it will have a mask. 0.0.0.1 ow
+ [ 'default', '0.0.0.0' ],
+ [ 'any', '0.0.0.0' ],
+ [-809041407, '207.199.2.1'],
+ [3485925889, '207.199.2.1'],
);
our @m = (
@@ -40,10 +42,10 @@
for my $a (@a) {
for my $m (@m) {
my $ip = new NetAddr::IP $a->[0], $m->[0];
- is($ip->addr, $a->[1]);
- is($ip->mask, $m->[1]);
- is($ip->bits, 32);
- is($ip->version, 4);
+ is($ip->addr, $a->[1], "$a->[0] / $m->[0] is $a->[1]");
+ is($ip->mask, $m->[1], "$a->[0] / $m->[0] is $m->[1]");
+ is($ip->bits, 32, "$a->[0] / $m->[0] is 32 bits wide");
+ is($ip->version, 4, "$a->[0] / $m->[0] is version 4");
}
}
diff --git a/t/v4-snew.t b/t/v4-snew.t
index 4c23b93..36e46f8 100644
--- a/t/v4-snew.t
+++ b/t/v4-snew.t
@@ -1,11 +1,14 @@
+use Test::More;
use NetAddr::IP;
-# $Id: v4-snew.t,v 1.2 2002/10/31 04:30:36 lem Exp $
+# $Id: v4-snew.t,v 1.3 2003/05/29 17:45:00 lem Exp $
my %w = ('broadcast' => [ '255.255.255.255', '255.255.255.255' ],
'default' => [ '0.0.0.0', '0.0.0.0' ],
'loopback' => [ '127.0.0.1', '255.0.0.0' ],
'10.' => [ '10.0.0.0', '255.0.0.0' ],
+ '10/8' => [ '10.0.0.0', '255.0.0.0' ],
+ '127/8' => [ '127.0.0.0', '255.0.0.0' ],
'11.11.' => [ '11.11.0.0', '255.255.0.0' ],
'12.12.12.' => [ '12.12.12.0', '255.255.255.0' ],
'13.13.13.13' => [ '13.13.13.13', '255.255.255.255' ],
@@ -19,26 +22,10 @@
'10.10.10' => [ '10.10.0.10', '255.255.255.255' ],
);
-$| = 1;
-
-print '1..', (2 * scalar keys %w), "\n";
-
-my $count = 1;
+plan tests => 2 * scalar keys %w;
for my $a (keys %w) {
my $ip = new NetAddr::IP $a;
-
- if ($ip->addr eq $w{$a}->[0]) {
- print "ok ", $count++, "\n";
- }
- else {
- print "not ok ", $count++, "\n";
- }
-
- if ($ip->mask eq $w{$a}->[1]) {
- print "ok ", $count++, "\n";
- }
- else {
- print "not ok ", $count++, "\n";
- }
+ is($ip->addr, $w{$a}->[0], "Matching ->addr()");
+ is($ip->mask, $w{$a}->[1], "Matching ->mask()");
}
diff --git a/t/v4-split-bulk.t b/t/v4-split-bulk.t
index 46695f3..f4554be 100644
--- a/t/v4-split-bulk.t
+++ b/t/v4-split-bulk.t
@@ -1,25 +1,23 @@
+use Test::More;
use NetAddr::IP;
-# $Id: v4-split-bulk.t,v 1.2 2002/10/31 04:30:36 lem Exp $
+# $Id: v4-split-bulk.t,v 1.3 2003/10/08 06:46:02 lem Exp $
my @addr = ( [ '10.0.0.0', 20, 32, 4096 ],
[ '10.0.0.0', 22, 32, 1024 ],
+ [ '10.0.0.0', 22, 24, 4 ],
+ [ '10.0.0.0', 22, 23, 2 ],
[ '10.0.0.0', 24, 32, 256 ],
- [ '10.0.0.0', 19, 32, 8192 ]
+ [ '10.0.0.0', 19, 32, 8192 ],
+ [ '10.0.0.0', 24, 24, 1 ],
+ [ '10.0.0.0', 31, 32, 2 ]
);
-my $count = $| = 1;
-print "1..", (scalar @addr), "\n";
+plan tests => (scalar @addr);
for my $a (@addr) {
my $ip = new NetAddr::IP $a->[0], $a->[1];
my $r = $ip->splitref($a->[2]);
- if (scalar @$r == $a->[3]) {
- print "ok ", $count++, "\n";
- }
- else {
- print "not ok ", $count++, " (number $a)\n";
- }
-
+ is(@$r, $a->[3]);
}
diff --git a/t/v6-base.t b/t/v6-base.t
index e1ce883..99a7dc2 100644
--- a/t/v6-base.t
+++ b/t/v6-base.t
@@ -1,21 +1,41 @@
# This -*- perl -*- code excercises the basic v6 functionality
-# $Id: v6-base.t,v 1.4 2002/12/17 05:09:50 lem Exp $
+# $Id: v6-base.t,v 1.7 2003/10/09 00:14:06 lem Exp $
-BEGIN { our @addr = qw(:: ::1 f34::123/40 ); };
+our @addr =
+ (
+ ['::', 3, '0000:0000:0000:0000:0000:0000:0000:0000/128'],
+ ['::1', 3, '0000:0000:0000:0000:0000:0000:0000:0001/128'],
+ ['f34::123/40', 3, '0f34:0000:0000:0000:0000:0000:0000:0003/40'],
+ ['dead:beef::1/40', 3, 'dead:beef:0000:0000:0000:0000:0000:0003/40'],
+ ['dead:beef::1/40', 4, 'dead:beef:0000:0000:0000:0000:0000:0004/40'],
+ ['dead:beef::1/40', 5, 'dead:beef:0000:0000:0000:0000:0000:0005/40'],
+ ['dead:beef::1/40', 6, 'dead:beef:0000:0000:0000:0000:0000:0006/40'],
+ ['dead:beef::1/40', 7, 'dead:beef:0000:0000:0000:0000:0000:0007/40'],
+ ['dead:beef::1/40', 8, 'dead:beef:0000:0000:0000:0000:0000:0008/40'],
+ ['dead:beef::1/40', 9, 'dead:beef:0000:0000:0000:0000:0000:0009/40'],
+ ['dead:beef::1/40', 255, 'dead:beef:0000:0000:0000:0000:0000:00ff/40'],
+ ['dead:beef::1/40', 256, 'dead:beef:0000:0000:0000:0000:0000:0100/40'],
+ ['dead:beef::1/40', 257, 'dead:beef:0000:0000:0000:0000:0000:0101/40'],
+ ['dead:beef::1/40', 65536, 'dead:beef:0000:0000:0000:0000:0001:0000/40'],
+ ['dead:beef::1/40', 65537, 'dead:beef:0000:0000:0000:0000:0001:0001/40'],
+ );
use NetAddr::IP;
-use Test::More tests => 4 * @addr + 4;
+use Test::More;
my($a, $ip, $test);
+plan tests => 5 * @addr + 4;
+
for $a (@addr) {
- $ip = new NetAddr::IP $a;
- $a =~ s,/\d+,,;
+ $ip = new NetAddr::IP $a->[0];
+ $a->[0] =~ s,/\d+,,;
isa_ok($ip, 'NetAddr::IP');
- is($ip->compact_addr, $a);
+ is($ip->compact_addr, $a->[0]);
is($ip->bits, 128);
is($ip->version, 6);
+ is($ip->nth($a->[1]), $a->[2]);
}
$test = new NetAddr::IP f34::1;
@@ -28,3 +48,4 @@
+
diff --git a/t/v6-split-bulk.t b/t/v6-split-bulk.t
new file mode 100644
index 0000000..bc09a0d
--- /dev/null
+++ b/t/v6-split-bulk.t
@@ -0,0 +1,28 @@
+use Test::More;
+use NetAddr::IP;
+
+# $Id: v6-split-bulk.t,v 1.2 2003/10/09 00:14:06 lem Exp $
+
+my @addr = (
+ [ 'dead:beef::1', 126, 127, 2 ],
+ [ 'dead:beef::1', 127, 127, 1 ],
+ [ 'dead:beef::1', 127, 128, 2 ],
+ [ 'dead:beef::1', 128, 128, 1 ],
+ [ 'dead:beef::1', 124, 128, 16 ],
+ [ 'dead:beef::1', 124, 127, 8 ],
+ );
+
+plan tests => (scalar @addr);
+
+SKIP: {
+
+ skip "NetAddr::IP cannot properly split() v6 addresses yet...",
+ scalar @addr unless $ENV{V6DEBUG};
+
+ for my $a (@addr) {
+ my $ip = new NetAddr::IP $a->[0], $a->[1];
+ my $r = $ip->splitref($a->[2]);
+# diag "$_\n" for @$r;
+ is(@$r, $a->[3]);
+ }
+};
diff --git a/tutorial.htm b/tutorial.htm
index 9b252d7..6e297fa 100644
--- a/tutorial.htm
+++ b/tutorial.htm
@@ -3,7 +3,12 @@
<TITLE>A tutorial for NetAddr::IP</TITLE>
</HEAD><BODY>
-<tt>$Id: tutorial.htm,v 1.2 2002/10/31 04:30:23 lem Exp $</tt>
+<tt>$Id: tutorial.htm,v 1.3 2003/10/09 00:12:22 lem Exp $</tt>
+
+<P><FONT SIZE="small">This tutorial is kept online at <A
+HREF="http://mipagina.cantv.net/lem/perl/iptut.htm">this</A>
+location. Please see the online version if you can, as it is probably
+more up to date...</FONT></P>
<a name="about"><h2>What this tutorial is all about...</h2></a>