1IP(3) User Contributed Perl Documentation IP(3)
2
6 NetAddr::IP - Manages IPv4 and IPv6 addresses and subnets
7
9 use NetAddr::IP qw(
10 Compact
11 Coalesce
12 Zeros
13 Ones
14 V4mask
15 V4net
16 netlimit
17 :aton DEPRECATED
18 :lower
19 :upper
20 :old_storable
21 :old_nth
22 :rfc3021
23 :nofqdn
24 );
25 NOTE: NetAddr::IP::Util has a full complement of network address
27 utilities to convert back and forth between binary and text.
28 inet_aton, inet_ntoa, ipv6_aton, ipv6_ntoa
30 ipv6_n2x, ipv6_n2d inet_any2d, inet_n2dx,
31 inet_n2ad, inetanyto6, ipv6to4
32 See NetAddr::IP::Util
34 my $ip = new NetAddr::IP '127.0.0.1';
36 or if you prefer
37 my $ip = NetAddr::IP->new('127.0.0.1);
38 or from a packed IPv4 address
39 my $ip = new_from_aton NetAddr::IP (inet_aton('127.0.0.1'));
40 or from an octal filtered IPv4 address
41 my $ip = new_no NetAddr::IP '127.012.0.0';
42 print "The address is ", $ip->addr, " with mask ", $ip->mask, "\n" ;
44 if ($ip->within(new NetAddr::IP "127.0.0.0", "255.0.0.0")) {
46 print "Is a loopback address\n";
47 }
48 # This prints 127.0.0.1/32
50 print "You can also say $ip...\n";
51 * The following four functions return ipV6 representations of:
53 :: = Zeros();
55 FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF = Ones();
56 FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:: = V4mask();
57 ::FFFF:FFFF = V4net();
58 Will also return an ipV4 or ipV6 representation of a
60 resolvable Fully Qualified Domanin Name (FQDN).
61 ###### DEPRECATED, will be remove in version 5 ############
63 * To accept addresses in the format as returned by
65 inet_aton, invoke the module as:
66 use NetAddr::IP qw(:aton);
68 ###### USE new_from_aton instead ##########################
70 * To enable usage of legacy data files containing NetAddr::IP objects
72 stored using the Storable module.
73 use NetAddr::IP qw(:old_storable);
75 * To compact many smaller subnets (see:
77 "$me->compact($addr1,$addr2,...)"
78 @compacted_object_list = Compact(@object_list)
80 * Return a reference to list of "NetAddr::IP" subnets of $masklen mask
82 length, when $number or more addresses from @list_of_subnets are found
83 to be contained in said subnet.
84 $arrayref = Coalesce($masklen, $number, @list_of_subnets)
86 * By default NetAddr::IP functions and methods return string IPv6
88 addresses in uppercase. To change that to lowercase:
89 NOTE: the AUGUST 2010 RFC5952 states:
91 4.3. Lowercase
93 The characters "a", "b", "c", "d", "e", and "f" in an IPv6
95 address MUST be represented in lowercase.
96 It is recommended that all NEW applications using NetAddr::IP be
98 invoked as shown on the next line.
99 use NetAddr::IP qw(:lower);
101 * To ensure the current IPv6 string case behavior even if the default
103 changes:
104 use NetAddr::IP qw(:upper);
106 * To set a limit on the size of nets processed or returned by
108 NetAddr::IP.
109 Set the maximum number of nets beyond which NetAddr::IP will return an
111 error as a power of 2 (default 16 or 65536 nets). Each 2**16 consumes
112 approximately 4 megs of memory. A 2**20 consumes 64 megs of memory, A
113 2**24 consumes 1 gigabyte of memory.
114 use NetAddr::IP qw(netlimit);
116 netlimit 20;
117 The maximum netlimit allowed is 2**24. Attempts to set limits below the
119 default of 16 or above the maximum of 24 are ignored.
120 Returns true on success, otherwise "undef".
122
124 Un-tar the distribution in an appropriate directory and type:
125 perl Makefile.PL
127 make
128 make test
129 make install
130 NetAddr::IP depends on NetAddr::IP::Util which installs by default with
132 its primary functions compiled using Perl's XS extensions to build a C
133 library. If you do not have a C complier available or would like the
134 slower Pure Perl version for some other reason, then type:
135 perl Makefile.PL -noxs
137 make
138 make test
139 make install
140
142 This module provides an object-oriented abstraction on top of IP
143 addresses or IP subnets that allows for easy manipulations. Version
144 4.xx of NetAddr::IP will work with older versions of Perl and is
145 compatible with Math::BigInt.
146 The internal representation of all IP objects is in 128 bit IPv6
148 notation. IPv4 and IPv6 objects may be freely mixed.
149 Overloaded Operators
151 Many operators have been overloaded, as described below:
152 Assignment ("=")
154 Has been optimized to copy one NetAddr::IP object to another very
155 quickly.
156 "->copy()"
158 The assignment ("=") operation is only put in to operation when the
159 copied object is further mutated by another overloaded operation.
160 See overload SPECIAL SYMBOLS FOR "use overload" for details.
161 "->copy()" actually creates a new object when called.
163 Stringification
165 An object can be used just as a string. For instance, the following
166 code
167 my $ip = new NetAddr::IP '192.168.1.123';
169 print "$ip\n";
170 Will print the string 192.168.1.123/32.
172 Equality
174 You can test for equality with either "eq" or "==". "eq" allows
175 comparison with arbitrary strings as well as NetAddr::IP objects.
176 The following example:
177 if (NetAddr::IP->new('127.0.0.1','255.0.0.0') eq '127.0.0.1/8')
179 { print "Yes\n"; }
180 will print out "Yes".
182 Comparison with "==" requires both operands to be NetAddr::IP
184 objects.
185 In both cases, a true value is returned if the CIDR representation
187 of the operands is equal.
188 Comparison via >, <, >=, <=, <=> and "cmp"
190 Internally, all network objects are represented in 128 bit format.
191 The numeric representation of the network is compared through the
192 corresponding operation. Comparisons are tried first on the address
193 portion of the object and if that is equal then the NUMERIC cidr
194 portion of the masks are compared. This leads to the
195 counterintuitive result that
196 /24 > /16
198 Comparison should not be done on netaddr objects with different
200 CIDR as this may produce indeterminate - unexpected results, rather
201 the determination of which netblock is larger or smaller should be
202 done by comparing
203 $ip1->masklen <=> $ip2->masklen
205 Addition of a constant ("+")
207 Add a 32 bit signed constant to the address part of a NetAddr
208 object. This operation changes the address part to point so many
209 hosts above the current objects start address. For instance, this
210 code:
211 print NetAddr::IP->new('127.0.0.1/8') + 5;
213 will output 127.0.0.6/8. The address will wrap around at the
215 broadcast back to the network address. This code:
216 print NetAddr::IP->new('10.0.0.1/24') + 255;
218 outputs 10.0.0.0/24.
220 Returns the the unchanged object when the constant is missing or
222 out of range.
223 2147483647 <= constant >= -2147483648
225 Subtraction of a constant ("-")
227 The complement of the addition of a constant.
228 Difference ("-")
230 Returns the difference between the address parts of two NetAddr::IP
231 objects address parts as a 32 bit signed number.
232 Returns undef if the difference is out of range.
234 (See range restrictions on Addition above)
236 Auto-increment
238 Auto-incrementing a NetAddr::IP object causes the address part to
239 be adjusted to the next host address within the subnet. It will
240 wrap at the broadcast address and start again from the network
241 address.
242 Auto-decrement
244 Auto-decrementing a NetAddr::IP object performs exactly the
245 opposite of auto-incrementing it, as you would expect.
246 Serializing and Deserializing
248 This module defines hooks to collaborate with Storable for serializing
249 "NetAddr::IP" objects, through compact and human readable strings. You
250 can revert to the old format by invoking this module as
251 use NetAddr::IP ':old_storable';
253 You must do this if you have legacy data files containing NetAddr::IP
255 objects stored using the Storable module.
256 Methods
258 "->new([$addr, [ $mask|IPv6 ]])"
259 "->new6([$addr, [ $mask]])"
260 "->new_no([$addr, [ $mask]])"
261 "->new_from_aton($netaddr)"
262 new_cis and new_cis6 are DEPRECATED
263 "->new_cis("$addr $mask)"
264 "->new_cis6("$addr $mask)"
265 The first two methods create a new address with the supplied
266 address in $addr and an optional netmask $mask, which can be
267 omitted to get a /32 or /128 netmask for IPv4 / IPv6 addresses
268 respectively.
269 The third method "new_no" is exclusively for IPv4 addresses and
271 filters improperly formatted dot quad strings for leading 0's that
272 would normally be interpreted as octal format by NetAddr per the
273 specifications for inet_aton.
274 new_from_aton takes a packed IPv4 address and assumes a /32 mask.
276 This function replaces the DEPRECATED :aton functionality which is
277 fundamentally broken.
278 The last two methods new_cis and new_cis6 differ from new and new6
280 only in that they except the common Cisco address notation for
281 address/mask pairs with a space as a separator instead of a slash
282 (/)
283 These methods are DEPRECATED because the functionality is now
285 included in the other "new" methods
286 i.e. ->new_cis('1.2.3.0 24')
288 or
289 ->new_cis6('::1.2.3.0 120')
290 "->new6" and "->new_cis6" mark the address as being in ipV6 address
292 space even if the format would suggest otherwise.
293 i.e. ->new6('1.2.3.4') will result in ::102:304
295 addresses submitted to ->new in ipV6 notation will
297 remain in that notation permanently. i.e.
298 ->new('::1.2.3.4') will result in ::102:304
299 whereas new('1.2.3.4') would print out as 1.2.3.4
300 See "STRINGIFICATION" below.
302 $addr can be almost anything that can be resolved to an IP address
304 in all the notations I have seen over time. It can optionally
305 contain the mask in CIDR notation.
306 prefix notation is understood, with the limitation that the range
308 specified by the prefix must match with a valid subnet.
309 Addresses in the same format returned by "inet_aton" or
311 "gethostbyname" can also be understood, although no mask can be
312 specified for them. The default is to not attempt to recognize this
313 format, as it seems to be seldom used.
314 To accept addresses in that format, invoke the module as in
316 use NetAddr::IP ':aton'
318 If called with no arguments, 'default' is assumed.
320 If called with an empty string as the argument, returns 'undef'
322 $addr can be any of the following and possibly more...
324 n.n
326 n.n/mm
327 n.n.n
328 n.n.n/mm
329 n.n.n.n
330 n.n.n.n/mm 32 bit cidr notation
331 n.n.n.n/m.m.m.m
332 loopback, localhost, broadcast, any, default
333 x.x.x.x/host
334 0xABCDEF, 0b111111000101011110, (a bcd number)
335 a netaddr as returned by 'inet_aton'
336 Any RFC1884 notation
338 ::n.n.n.n
340 ::n.n.n.n/mmm 128 bit cidr notation
341 ::n.n.n.n/::m.m.m.m
342 ::x:x
343 ::x:x/mmm
344 x:x:x:x:x:x:x:x
345 x:x:x:x:x:x:x:x/mmm
346 x:x:x:x:x:x:x:x/m:m:m:m:m:m:m:m any RFC1884 notation
347 loopback, localhost, unspecified, any, default
348 ::x:x/host
349 0xABCDEF, 0b111111000101011110 within the limits
350 of perl's number resolution
351 123456789012 a 'big' bcd number (bigger than perl likes)
352 and Math::BigInt
353 A Fully Qualified Domain Name which returns an ipV4 address or an
355 ipV6 address, embodied in that order. This previously undocumented
356 feature may be disabled with:
357 use NetAddr::IP::Lite ':nofqdn';
359 If called with no arguments, 'default' is assumed.
361 If called with an empty string as the argument, returns 'undef'
363 "->broadcast()"
365 Returns a new object referring to the broadcast address of a given
366 subnet. The broadcast address has all ones in all the bit positions
367 where the netmask has zero bits. This is normally used to address
368 all the hosts in a given subnet.
369 "->network()"
371 Returns a new object referring to the network address of a given
372 subnet. A network address has all zero bits where the bits of the
373 netmask are zero. Normally this is used to refer to a subnet.
374 "->addr()"
376 Returns a scalar with the address part of the object as an IPv4 or
377 IPv6 text string as appropriate. This is useful for printing or for
378 passing the address part of the NetAddr::IP object to other
379 components that expect an IP address. If the object is an ipV6
380 address or was created using ->new6($ip) it will be reported in
381 ipV6 hex format otherwise it will be reported in dot quad format
382 only if it resides in ipV4 address space.
383 "->mask()"
385 Returns a scalar with the mask as an IPv4 or IPv6 text string as
386 described above.
387 "->masklen()"
389 Returns a scalar the number of one bits in the mask.
390 "->bits()"
392 Returns the width of the address in bits. Normally 32 for v4 and
393 128 for v6.
394 "->version()"
396 Returns the version of the address or subnet. Currently this can be
397 either 4 or 6.
398 "->cidr()"
400 Returns a scalar with the address and mask in CIDR notation. A
401 NetAddr::IP object stringifies to the result of this function.
402 (see comments about ->new6() and ->addr() for output formats)
403 "->aton()"
405 Returns the address part of the NetAddr::IP object in the same
406 format as the "inet_aton()" or "ipv6_aton" function respectively.
407 If the object was created using ->new6($ip), the address returned
408 will always be in ipV6 format, even for addresses in ipV4 address
409 space.
410 "->range()"
412 Returns a scalar with the base address and the broadcast address
413 separated by a dash and spaces. This is called range notation.
414 "->prefix()"
416 Returns a scalar with the address and mask in ipV4 prefix
417 representation. This is useful for some programs, which expect its
418 input to be in this format. This method will include the broadcast
419 address in the encoding.
420 "->nprefix()"
422 Just as "->prefix()", but does not include the broadcast address.
423 "->numeric()"
425 When called in a scalar context, will return a numeric
426 representation of the address part of the IP address. When called
427 in an array contest, it returns a list of two elements. The first
428 element is as described, the second element is the numeric
429 representation of the netmask.
430 This method is essential for serializing the representation of a
432 subnet.
433 "->bigint()"
435 When called in scalar context, will return a Math::BigInt
436 representation of the address part of the IP address. When called
437 in an array context, it returns a list of two elements, The first
438 element is as described, the second element is the Math::BigInt
439 representation of the netmask.
440 "->wildcard()"
442 When called in a scalar context, returns the wildcard bits
443 corresponding to the mask, in dotted-quad or ipV6 format as
444 applicable.
445 When called in an array context, returns a two-element array. The
447 first element, is the address part. The second element, is the
448 wildcard translation of the mask.
449 "->short()"
451 Returns the address part in a short or compact notation.
452 (ie, 127.0.0.1 becomes 127.1).
454 Works with both, V4 and V6.
456 "->canon()"
458 Returns the address part in canonical notation as a string. For
459 ipV4, this is dotted quad, and is the same as the return value from
460 "->addr()". For ipV6 it is as per RFC5952, and is the same as the
461 LOWER CASE value returned by "->short()".
462 "->full()"
464 Returns the address part in FULL notation for ipV4 and ipV6
465 respectively.
466 i.e. for ipV4
468 0000:0000:0000:0000:0000:0000:127.0.0.1
469 for ipV6
471 0000:0000:0000:0000:0000:0000:0000:0000
472 To force ipV4 addresses into full ipV6 format use:
474 "->full6()"
476 Returns the address part in FULL ipV6 notation
477 "->full6m()"
479 Returns the mask part in FULL ipV6 notation
480 "$me->contains($other)"
482 Returns true when $me completely contains $other. False is returned
483 otherwise and "undef" is returned if $me and $other are not both
484 "NetAddr::IP" objects.
485 "$me->within($other)"
487 The complement of "->contains()". Returns true when $me is
488 completely contained within $other.
489 Note that $me and $other must be "NetAddr::IP" objects.
491 C->is_rfc1918()>
493 Returns true when $me is an RFC 1918 address.
494 10.0.0.0 - 10.255.255.255 (10/8 prefix)
496 172.16.0.0 - 172.31.255.255 (172.16/12 prefix)
497 192.168.0.0 - 192.168.255.255 (192.168/16 prefix)
498 "->is_local()"
500 Returns true when $me is a local network address.
501 i.e. ipV4 127.0.0.0 - 127.255.255.255
503 or ipV6 === ::1
504 "->splitref($bits,[optional $bits1,$bits2,...])"
506 Returns a reference to a list of objects, representing subnets of
507 "bits" mask produced by splitting the original object, which is
508 left unchanged. Note that $bits must be longer than the original
509 mask in order for it to be splittable.
510 ERROR conditions:
512 ->splitref will DIE with the message 'netlimit exceeded'
514 if the number of return objects exceeds 'netlimit'.
515 See function 'netlimit' above (default 2**16 or 65536 nets).
516 ->splitref returns undef when C<bits> or the (bits list)
518 will not fit within the original object.
519 ->splitref returns undef if a supplied ipV4, ipV6, or NetAddr
521 mask in inappropriately formatted,
522 bits may be a CIDR mask, a dot quad or ipV6 string or a NetAddr::IP
524 object. If "bits" is missing, the object is split for into all
525 available addresses within the ipV4 or ipV6 object ( auto-mask of
526 CIDR 32, 128 respectively ).
527 With optional additional "bits" list, the original object is split
529 into parts sized based on the list. NOTE: a short list will
530 replicate the last item. If the last item is too large to for what
531 remains of the object after splitting off the first parts of the
532 list, a "best fits" list of remaining objects will be returned
533 based on an increasing sort of the CIDR values of the "bits" list.
534 i.e. my $ip = new NetAddr::IP('192.168.0.0/24');
536 my $objptr = $ip->split(28, 29, 28, 29, 26);
537 has split plan 28 29 28 29 26 26 26 28
539 and returns this list of objects
540 192.168.0.0/28
542 192.168.0.16/29
543 192.168.0.24/28
544 192.168.0.40/29
545 192.168.0.48/26
546 192.168.0.112/26
547 192.168.0.176/26
548 192.168.0.240/28
549 NOTE: that /26 replicates twice beyond the original request and /28
551 fills the remaining return object requirement.
552 "->rsplitref($bits,[optional $bits1,$bits2,...])"
554 "->rsplitref" is the same as "->splitref" above except that the
555 split plan is applied to the original object in reverse order.
556 i.e. my $ip = new NetAddr::IP('192.168.0.0/24');
558 my @objects = $ip->split(28, 29, 28, 29, 26);
559 has split plan 28 26 26 26 29 28 29 28
561 and returns this list of objects
562 192.168.0.0/28
564 192.168.0.16/26
565 192.168.0.80/26
566 192.168.0.144/26
567 192.168.0.208/29
568 192.168.0.216/28
569 192.168.0.232/29
570 192.168.0.240/28
571 "->split($bits,[optional $bits1,$bits2,...])"
573 Similar to "->splitref" above but returns the list rather than a
574 list reference. You may not want to use this if a large number of
575 objects is expected.
576 "->rsplit($bits,[optional $bits1,$bits2,...])"
578 Similar to "->rsplitref" above but returns the list rather than a
579 list reference. You may not want to use this if a large number of
580 objects is expected.
581 "->hostenum()"
583 Returns the list of hosts within a subnet.
584 ERROR conditions:
586 ->hostenum will DIE with the message 'netlimit exceeded'
588 if the number of return objects exceeds 'netlimit'.
589 See function 'netlimit' above (default 2**16 or 65536 nets).
590 "->hostenumref()"
592 Faster version of "->hostenum()", returning a reference to a list.
593 NOTE: hostenum and hostenumref report zero (0) useable hosts in a
595 /31 network. This is the behavior expected prior to RFC 3021. To
596 report 2 useable hosts for use in point-to-point networks, use
597 :rfc3021 tag.
598 use NetAddr::IP qw(:rfc3021);
600 This will cause hostenum and hostenumref to return two (2) useable
602 hosts in a /31 network.
603 "$me->compact($addr1, $addr2, ...)"
605 "@compacted_object_list = Compact(@object_list)"
606 Given a list of objects (including $me), this method will compact
607 all the addresses and subnets into the largest (ie, least specific)
608 subnets possible that contain exactly all of the given objects.
609 Note that in versions prior to 3.02, if fed with the same IP
611 subnets multiple times, these subnets would be returned. From 3.02
612 on, a more "correct" approach has been adopted and only one address
613 would be returned.
614 Note that $me and all $addr's must be "NetAddr::IP" objects.
616 "$me->compactref(\@list)"
618 "$compacted_object_list = Compact(\@list)"
619 As usual, a faster version of "->compact()" that returns a
620 reference to a list. Note that this method takes a reference to a
621 list instead.
622 Note that $me must be a "NetAddr::IP" object.
624 "$me->coalesce($masklen, $number, @list_of_subnets)"
626 "$arrayref = Coalesce($masklen,$number,@list_of_subnets)"
627 Will return a reference to list of "NetAddr::IP" subnets of
628 $masklen mask length, when $number or more addresses from
629 @list_of_subnets are found to be contained in said subnet.
630 Subnets from @list_of_subnets with a mask shorter than $masklen are
632 passed "as is" to the return list.
633 Subnets from @list_of_subnets with a mask longer than $masklen will
635 be counted (actually, the number of IP addresses is counted)
636 towards $number.
637 Called as a method, the array will include $me.
639 WARNING: the list of subnet must be the same type. i.e ipV4 or ipV6
641 "->first()"
643 Returns a new object representing the first usable IP address
644 within the subnet (ie, the first host address).
645 "->last()"
647 Returns a new object representing the last usable IP address within
648 the subnet (ie, one less than the broadcast address).
649 "->nth($index)"
651 Returns a new object representing the n-th usable IP address within
652 the subnet (ie, the n-th host address). If no address is available
653 (for example, when the network is too small for $index hosts),
654 "undef" is returned.
655 Version 4.00 of NetAddr::IP and version 1.00 of NetAddr::IP::Lite
657 implements "->nth($index)" and "->num()" exactly as the
658 documentation states. Previous versions behaved slightly
659 differently and not in a consistent manner. See the README file for
660 details.
661 To use the old behavior for "->nth($index)" and "->num()":
663 use NetAddr::IP::Lite qw(:old_nth);
665 old behavior:
667 NetAddr::IP->new('10/32')->nth(0) == undef
668 NetAddr::IP->new('10/32')->nth(1) == undef
669 NetAddr::IP->new('10/31')->nth(0) == undef
670 NetAddr::IP->new('10/31')->nth(1) == 10.0.0.1/31
671 NetAddr::IP->new('10/30')->nth(0) == undef
672 NetAddr::IP->new('10/30')->nth(1) == 10.0.0.1/30
673 NetAddr::IP->new('10/30')->nth(2) == 10.0.0.2/30
674 NetAddr::IP->new('10/30')->nth(3) == 10.0.0.3/30
675 Note that in each case, the broadcast address is represented in the
677 output set and that the 'zero'th index is alway undef except for a
678 point-to-point /31 or /127 network where there are exactly two
679 addresses in the network.
680 new behavior:
682 NetAddr::IP->new('10/32')->nth(0) == 10.0.0.0/32
683 NetAddr::IP->new('10.1/32'->nth(0) == 10.0.0.1/32
684 NetAddr::IP->new('10/31')->nth(0) == 10.0.0.0/31
685 NetAddr::IP->new('10/31')->nth(1) == 10.0.0.1/31
686 NetAddr::IP->new('10/30')->nth(0) == 10.0.0.1/30
687 NetAddr::IP->new('10/30')->nth(1) == 10.0.0.2/30
688 NetAddr::IP->new('10/30')->nth(2) == undef
689 Note that a /32 net always has 1 usable address while a /31 has
691 exactly two usable addresses for point-to-point addressing. The
692 first index (0) returns the address immediately following the
693 network address except for a /31 or /127 when it return the network
694 address.
695 "->num()"
697 As of version 4.42 of NetAddr::IP and version 1.27 of
698 NetAddr::IP::Lite a /31 and /127 with return a net num value of 2
699 instead of 0 (zero) for point-to-point networks.
700 Version 4.00 of NetAddr::IP and version 1.00 of NetAddr::IP::Lite
702 return the number of usable IP addresses within the subnet, not
703 counting the broadcast or network address.
704 Previous versions worked only for ipV4 addresses, returned a
706 maximum span of 2**32 and returned the number of IP addresses not
707 counting the broadcast address.
708 (one greater than the new behavior)
709 To use the old behavior for "->nth($index)" and "->num()":
711 use NetAddr::IP::Lite qw(:old_nth);
713 WARNING:
715 NetAddr::IP will calculate and return a numeric string for network
717 ranges as large as 2**128. These values are TEXT strings and perl
718 can treat them as integers for numeric calculations.
719 Perl on 32 bit platforms only handles integer numbers up to 2**32
721 and on 64 bit platforms to 2**64.
722 If you wish to manipulate numeric strings returned by NetAddr::IP
724 that are larger than 2**32 or 2**64, respectively, you must load
725 additional modules such as Math::BigInt, bignum or some similar
726 package to do the integer math.
727 "->re()"
729 Returns a Perl regular expression that will match an IP address
730 within the given subnet. Defaults to ipV4 notation. Will return an
731 ipV6 regex if the address in not in ipV4 space.
732 "->re6()"
734 Returns a Perl regular expression that will match an IP address
735 within the given subnet. Always returns an ipV6 regex.
736
738 Compact
739 Coalesce
740 Zeros
741 Ones
742 V4mask
743 V4net
744 netlimit
745
747 NetAddr::IP only runs in Pure Perl mode on Windows boxes because I
748 don't have the resources or know how to get the "configure" stuff
749 working in the Windows environment. Volunteers WELCOME to port the "C"
750 portion of this module to Windows.
751
753 See the Changes file
754
756 Luis E. Muñoz <luismunoz@cpan.org>, Michael Robinton
757 <michael@bizsystems.com>
758
760 This software comes with the same warranty as Perl itself (ie, none),
761 so by using it you accept any and all the liability.
762
764 This software is (c) Luis E. Muñoz, 1999 - 2007, and (c) Michael
765 Robinton, 2006 - 2014.
766 All rights reserved.
768 This program is free software; you can redistribute it and/or modify it
770 under the terms of either:
771 a) the GNU General Public License as published by the Free
773 Software Foundation; either version 2, or (at your option) any
774 later version, or
775 b) the "Artistic License" which comes with this distribution.
777 This program is distributed in the hope that it will be useful, but
779 WITHOUT ANY WARRANTY; without even the implied warranty of
780 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See either the
781 GNU General Public License or the Artistic License for more details.
782 You should have received a copy of the Artistic License with this
784 distribution, in the file named "Artistic". If not, I'll be glad to
785 provide one.
786 You should also have received a copy of the GNU General Public License
788 along with this program in the file named "Copying". If not, write to
789 the
790 Free Software Foundation, Inc.
792 51 Franklin Street, Fifth Floor
793 Boston, MA 02110-1301 USA.
794 or visit their web page on the internet at:
796 http://www.gnu.org/copyleft/gpl.html.
798
800 perl(1) L<NetAddr::IP::Lite>, L<NetAddr::IP::Util>,
801 L<NetAddr::IP::InetBase>
802perl v5.34.0 2021-07-22 IP(3)