diff --git a/NetAddr-IP-4.030.tar.bz2 b/NetAddr-IP-4.030.tar.bz2 deleted file mode 100644 index f46b011..0000000 --- a/NetAddr-IP-4.030.tar.bz2 +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:e71f61a49051459a33c989a8a77ddb8bed683c9fa01ecda93b18868c7bcb49b3 -size 115022 diff --git a/NetAddr-IP-4.042.tar.gz b/NetAddr-IP-4.042.tar.gz new file mode 100644 index 0000000..114b265 --- /dev/null +++ b/NetAddr-IP-4.042.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c261d0bc46f3a776772c6d83646caa92b7ffd79d6f613b79d5e21f6796291138 +size 148775 diff --git a/perl-NetAddr-IP.changes b/perl-NetAddr-IP.changes index ab7c065..8654edb 100644 --- a/perl-NetAddr-IP.changes +++ b/perl-NetAddr-IP.changes @@ -1,3 +1,9 @@ +------------------------------------------------------------------- +Thu Mar 31 08:47:06 UTC 2011 - coolo@novell.com + +- initial package 4.042 + * a lot of changes, see Changes + ------------------------------------------------------------------- Wed Dec 1 13:34:02 UTC 2010 - coolo@novell.com diff --git a/perl-NetAddr-IP.spec b/perl-NetAddr-IP.spec index d13bd3a..9c75201 100644 --- a/perl-NetAddr-IP.spec +++ b/perl-NetAddr-IP.spec @@ -1,5 +1,5 @@ # -# spec file for package perl-NetAddr-IP (Version 4.030) +# spec file for package perl-NetAddr-IP (Version 4.042) # # Copyright (c) 2010 SUSE LINUX Products GmbH, Nuernberg, Germany. # @@ -15,44 +15,618 @@ # Please submit bugfixes or comments via http://bugs.opensuse.org/ # -# norootforbuild - -%bcond_with pod - Name: perl-NetAddr-IP -%define cpan_name NetAddr-IP -Summary: Manages IPv4 and IPv6 addresses and subnets -Version: 4.030 +Version: 4.042 Release: 1 License: CHECK(GPL+ or Artistic) -Group: Development/Libraries/Perl +%define cpan_name NetAddr-IP +Summary: Manages IPv4 and IPv6 addresses and subnets Url: http://search.cpan.org/dist/NetAddr-IP/ -#Source: http://www.cpan.org/modules/by-module/NetAddr/NetAddr-IP-%{version}.tar.gz -Source: %{cpan_name}-%{version}.tar.bz2 +Group: Development/Libraries/Perl +#Source: http://www.cpan.org/authors/id/M/MI/MIKER/NetAddr-IP-%{version}.tar.gz +Source: %{cpan_name}-%{version}.tar.gz BuildRoot: %{_tmppath}/%{name}-%{version}-build -%{perl_requires} BuildRequires: perl BuildRequires: perl-macros -%if %{with pod} -BuildRequires: perl(Test::Pod) -BuildRequires: perl(Pod::Coverage) -%endif +%{perl_requires} %description This module provides an object-oriented abstraction on top of IP addresses or IP subnets, that allows for easy manipulations. Version 4.xx of -NetAdder::IP will will work older versions of Perl and does not use +NetAdder::IP will will work older versions of Perl and does *not* use Math::BigInt as in previous versions. -Authors: --------- - Luis E. Munoz +The internal representation of all IP objects is in 128 bit IPv6 notation. +IPv4 and IPv6 objects may be freely mixed. + +Overloaded Operators + Many operators have been overloaded, as described below: + + * *Assignment ('=')* + + Has been optimized to copy one NetAddr::IP object to another very + quickly. + + * *'->copy()'* + + The *assignment ('=')* operation is only put in to operation when the + copied object is further mutated by another overloaded operation. See + the overload manpage *SPECIAL SYMBOLS FOR "use overload"* for + details. + + *'->copy()'* actually creates a new object when called. + + * *Stringification* + + An object can be used just as a string. For instance, the following + code + + my $ip = new NetAddr::IP '192.168.1.123'; + print "$ip\n"; + + Will print the string 192.168.1.123/32. + + * *Equality* + + You can test for equality with either 'eq' or '=='. 'eq' allows the + comparison with arbitrary strings as well as NetAddr::IP objects. The + following example: + + if (NetAddr::IP->new('127.0.0.1','255.0.0.0') eq '127.0.0.1/8') + { print "Yes\n"; } + + Will print out "Yes". + + Comparison with '==' requires both operands to be NetAddr::IP + objects. + + In both cases, a true value is returned if the CIDR representation of + the operands is equal. + + * *Comparison via >, <, >=, <=, <=> and 'cmp'* + + Internally, all network objects are represented in 128 bit format. + The numeric representation of the network is compared through the + corresponding operation. Comparisons are tried first on the address + portion of the object and if that is equal then the NUMERIC cidr + portion of the masks are compared. This leads to the counterintuitive + result that + + /24 > /16 + + Comparison should not be done on netaddr objects with different CIDR + as this may produce indeterminate - unexpected results, rather the + determination of which netblock is larger or smaller should be done + by comparing + + $ip1->masklen <=> $ip2->masklen + + * *Addition of a constant ('+')* + + Add a 32 bit signed constant to the address part of a NetAddr object. + This operation changes the address part to point so many hosts above + the current objects start address. For instance, this code: + + print NetAddr::IP::Lite->new('127.0.0.1') + 5; + + will output 127.0.0.6/8. The address will wrap around at the + broadcast back to the network address. This code: + + print NetAddr::IP::Lite->new('10.0.0.1/24') + 255; + + outputs 10.0.0.0/24. + + Returns the the unchanged object when the constant is missing or out + of range. + + 2147483647 <= constant >= -2147483648 + + * *Subtraction of a constant ('-')* + + The complement of the addition of a constant. + + * *Difference ('-')* + + Returns the difference between the address parts of two + NetAddr::IP::Lite objects address parts as a 32 bit signed number. + + Returns *undef* if the difference is out of range. + + (See range restrictions on Addition above) + + * *Auto-increment* + + Auto-incrementing a NetAddr::IP object causes the address part to be + adjusted to the next host address within the subnet. It will wrap at + the broadcast address and start again from the network address. + + * *Auto-decrement* + + Auto-decrementing a NetAddr::IP object performs exactly the opposite + of auto-incrementing it, as you would expect. + +Serializing and Deserializing + This module defines hooks to collaborate with the Storable manpage for + serializing 'NetAddr::IP' objects, through compact and human readable + strings. You can revert to the old format by invoking this module as + + use NetAddr::IP ':old_storable'; + + You must do this if you have legacy data files containing NetAddr::IP + objects stored using the the Storable manpage module. + +Methods + * '->new([$addr, [ $mask|IPv6 ]])' + + * '->new6([$addr, [ $mask]])' + + * '->new_no([$addr, [ $mask]])' + + * '->new_from_aton($netaddr)' + + * new_cis and new_cis6 are DEPRECATED + + * '->new_cis("$addr $mask)' + + * '->new_cis6("$addr $mask)' + + The first two methods create a new address with the supplied address + in '$addr' and an optional netmask '$mask', which can be omitted to + get a /32 or /128 netmask for IPv4 / IPv6 addresses respectively. + + The third method 'new_no' is exclusively for IPv4 addresses and + filters improperly formatted dot quad strings for leading 0's that + would normally be interpreted as octal format by NetAddr per the + specifications for inet_aton. + + *new_from_aton* takes a packed IPv4 address and assumes a /32 mask. + This function replaces the DEPRECATED :aton functionality which is + fundamentally broken. + + The last two methods *new_cis* and *new_cis6* differ from *new* and + *new6* only in that they except the common Cisco address notation for + address/mask pairs with a *space* as a separator instead of a slash + (/) + + These methods are DEPRECATED because the functionality is now + included in the other "new" methods + + i.e. ->new_cis('1.2.3.0 24') + or + ->new_cis6('::1.2.3.0 120') + + '->new6' and '->new_cis6' mark the address as being in ipV6 address + space even if the format would suggest otherwise. + + i.e. ->new6('1.2.3.4') will result in ::102:304 + + addresses submitted to ->new in ipV6 notation will + remain in that notation permanently. i.e. + ->new('::1.2.3.4') will result in ::102:304 + whereas new('1.2.3.4') would print out as 1.2.3.4 + + See "STRINGIFICATION" below. + + '$addr' can be almost anything that can be resolved to an IP address + in all the notations I have seen over time. It can optionally contain + the mask in CIDR notation. + + *prefix* notation is understood, with the limitation that the range + specified by the prefix must match with a valid subnet. + + Addresses in the same format returned by 'inet_aton' or + 'gethostbyname' can also be understood, although no mask can be + specified for them. The default is to not attempt to recognize this + format, as it seems to be seldom used. + + To accept addresses in that format, invoke the module as in + + use NetAddr::IP ':aton' + + If called with no arguments, 'default' is assumed. + + '$addr' can be any of the following and possibly more... + + n.n + n.n/mm + n.n.n + n.n.n/mm + n.n.n.n + n.n.n.n/mm 32 bit cidr notation + n.n.n.n/m.m.m.m + loopback, localhost, broadcast, any, default + x.x.x.x/host + 0xABCDEF, 0b111111000101011110, (a bcd number) + a netaddr as returned by 'inet_aton' + + Any RFC1884 notation + + ::n.n.n.n + ::n.n.n.n/mmm 128 bit cidr notation + ::n.n.n.n/::m.m.m.m + ::x:x + ::x:x/mmm + x:x:x:x:x:x:x:x + x:x:x:x:x:x:x:x/mmm + x:x:x:x:x:x:x:x/m:m:m:m:m:m:m:m any RFC1884 notation + loopback, localhost, unspecified, any, default + ::x:x/host + 0xABCDEF, 0b111111000101011110 within the limits + of perl's number resolution + 123456789012 a 'big' bcd number i.e. Math::BigInt + + If called with no arguments, 'default' is assumed. + + * '->broadcast()' + + Returns a new object referring to the broadcast address of a given + subnet. The broadcast address has all ones in all the bit positions + where the netmask has zero bits. This is normally used to address all + the hosts in a given subnet. + + * '->network()' + + Returns a new object referring 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. + + * '->addr()' + + Returns a scalar with the address part of the object as an IPv4 or + IPv6 text string as appropriate. This is useful for printing or for + passing the address part of the NetAddr::IP object to other + components that expect an IP address. If the object is an ipV6 + address or was created using ->new6($ip) it will be reported in ipV6 + hex format otherwise it will be reported in dot quad format only if + it resides in ipV4 address space. + + * '->mask()' + + Returns a scalar with the mask as an IPv4 or IPv6 text string as + described above. + + * '->masklen()' + + Returns a scalar the number of one bits in the mask. + + * '->bits()' + + Returns the width of the address in bits. Normally 32 for v4 and 128 + for v6. + + * '->version()' + + Returns the version of the address or subnet. Currently this can be + either 4 or 6. + + * '->cidr()' + + Returns a scalar with the address and mask in CIDR notation. A + NetAddr::IP object _stringifies_ to the result of this function. (see + comments about ->new6() and ->addr() for output formats) + + * '->aton()' + + Returns the address part of the NetAddr::IP object in the same format + as the 'inet_aton()' or 'ipv6_aton' function respectively. If the + object was created using ->new6($ip), the address returned will + always be in ipV6 format, even for addresses in ipV4 address space. + + * '->range()' + + Returns a scalar with the base address and the broadcast address + separated by a dash and spaces. This is called range notation. + + * '->prefix()' + + Returns a scalar with the address and mask in ipV4 prefix + representation. This is useful for some programs, which expect its + input to be in this format. This method will include the broadcast + address in the encoding. + + * '->nprefix()' + + Just as '->prefix()', but does not include the broadcast address. + + * '->numeric()' + + When called in a scalar context, will return a numeric representation + of the address part of the IP address. When called in an array + contest, it returns a list of two elements. The first element is as + described, the second element is the numeric representation of the + netmask. + + This method is essential for serializing the representation of a + subnet. + + * '->wildcard()' + + When called in a scalar context, returns the wildcard bits + corresponding to the mask, in dotted-quad or ipV6 format as + applicable. + + When called in an array context, returns a two-element array. The + first element, is the address part. The second element, is the + wildcard translation of the mask. + + * '->short()' + + Returns the address part in a short or compact notation. + + (ie, 127.0.0.1 becomes 127.1). + + Works with both, V4 and V6. + + * '->full()' + + Returns the address part in FULL notation for ipV4 and ipV6 + respectively. + + i.e. for ipV4 + 0000:0000:0000:0000:0000:0000:127.0.0.1 + + for ipV6 + 0000:0000:0000:0000:0000:0000:0000:0000 + + To force ipV4 addresses into full ipV6 format use: + + * '->full6()' + + Returns the address part in FULL ipV6 notation + + * '$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. + + * '$me->within($other)' + + The complement of '->contains()'. Returns true when '$me' is + completely contained within '$other'. + + Note that '$me' and '$other' must be 'NetAddr::IP' objects. + + * '->splitref($bits,[optional $bits1,$bits2,...])' + + Returns a reference to a list of objects, representing subnets of + 'bits' mask produced by splitting the original object, which is left + unchanged. Note that '$bits' must be longer than the original mask in + order for it to be splittable. + + ERROR conditions: + + ->splitref will DIE with the message 'netlimit exceeded' + if the number of return objects exceeds 'netlimit'. + See function 'netlimit' above (default 2**16 or 65536 nets). + + ->splitref returns undef when C or the (bits list) + will not fit within the original object. + + ->splitref returns undef if a supplied ipV4, ipV6, or NetAddr + mask in inappropriately formatted, + + *bits* may be a CIDR mask, a dot quad or ipV6 string or a NetAddr::IP + object. If 'bits' is missing, the object is split for into all + available addresses within the ipV4 or ipV6 object ( auto-mask of + CIDR 32, 128 respectively ). + + With optional additional 'bits' list, the original object is split + into parts sized based on the list. NOTE: a short list will replicate + the last item. If the last item is too large to for what remains of + the object after splitting off the first parts of the list, a "best + fits" list of remaining objects will be returned based on an + increasing sort of the CIDR values of the 'bits' list. + + i.e. my $ip = new NetAddr::IP('192.168.0.0/24'); + my $objptr = $ip->split(28, 29, 28, 29, 26); + + has split plan 28 29 28 29 26 26 26 28 + and returns this list of objects + + 192.168.0.0/28 + 192.168.0.16/29 + 192.168.0.24/28 + 192.168.0.40/29 + 192.168.0.48/26 + 192.168.0.112/26 + 192.168.0.176/26 + 192.168.0.240/28 + + NOTE: that /26 replicates twice beyond the original request and /28 + fills the remaining return object requirement. + + * '->rsplitref($bits,[optional $bits1,$bits2,...])' + + '->rsplitref' is the same as '->splitref' above except that the split + plan is applied to the original object in reverse order. + + i.e. my $ip = new NetAddr::IP('192.168.0.0/24'); + my @objects = $ip->split(28, 29, 28, 29, 26); + + has split plan 28 26 26 26 29 28 29 28 + and returns this list of objects + + 192.168.0.0/28 + 192.168.0.16/26 + 192.168.0.80/26 + 192.168.0.144/26 + 192.168.0.208/29 + 192.168.0.216/28 + 192.168.0.232/29 + 192.168.0.240/28 + + * '->split($bits,[optional $bits1,$bits2,...])' + + Similar to '->splitref' above but returns the list rather than a list + reference. You may not want to use this if a large number of objects + is expected. + + * '->rsplit($bits,[optional $bits1,$bits2,...])' + + Similar to '->rsplitref' above but returns the list rather than a + list reference. You may not want to use this if a large number of + objects is expected. + + * '->hostenum()' + + Returns the list of hosts within a subnet. + + ERROR conditions: + + ->hostenum will DIE with the message 'netlimit exceeded' + if the number of return objects exceeds 'netlimit'. + See function 'netlimit' above (default 2**16 or 65536 nets). + + * '->hostenumref()' + + Faster version of '->hostenum()', returning a reference to a list. + + * '$me->compact($addr1, $addr2, ...)' + + * '@compacted_object_list = Compact(@object_list)' + + Given a list of objects (including '$me'), this method will compact + all the addresses and subnets into the largest (ie, least specific) + subnets possible that contain exactly all of the given objects. + + Note that in versions prior to 3.02, if fed with the same IP subnets + multiple times, these subnets would be returned. From 3.02 on, a more + "correct" approach has been adopted and only one address would be + returned. + + Note that '$me' and all '$addr''s must be 'NetAddr::IP' objects. + + * '$me->compactref(\@list)' + + As usual, a faster version of =item '->compact()' that returns a + reference to a list. Note that this method takes a reference to a + list instead. + + Note that '$me' must be a 'NetAddr::IP' object. + + * '$me->coalesce($masklen, $number, @list_of_subnets)' + + * '$arrayref = Coalesce($masklen,$number,@list_of_subnets)' + + Will return a reference to list of 'NetAddr::IP' subnets of + '$masklen' mask length, when '$number' or more addresses from + '@list_of_subnets' are found to be contained in said subnet. + + Subnets from '@list_of_subnets' with a mask shorter than '$masklen' + are passed "as is" to the return list. + + Subnets from '@list_of_subnets' with a mask longer than '$masklen' + will be counted (actually, the number of IP addresses is counted) + towards '$number'. + + Called as a method, the array will include '$me'. + + WARNING: the list of subnet must be the same type. i.e ipV4 or ipV6 + + * '->first()' + + Returns a new object representing the first usable IP address within + the subnet (ie, the first host address). + + * '->last()' + + Returns a new object representing the last usable IP address within + the subnet (ie, one less than the broadcast address). + + * '->nth($index)' + + Returns a new object representing the _n_-th usable IP address within + the subnet (ie, the _n_-th host address). If no address is available + (for example, when the network is too small for '$index' hosts), + 'undef' is returned. + + Version 4.00 of NetAddr::IP and version 1.00 of NetAddr::IP::Lite + implements '->nth($index)' and '->num()' exactly as the documentation + states. Previous versions behaved slightly differently and not in a + consistent manner. See the README file for details. + + To use the old behavior for '->nth($index)' and '->num()': + + use NetAddr::IP::Lite qw(:old_nth); + + old behavior: + NetAddr::IP->new('10/32')->nth(0) == undef + NetAddr::IP->new('10/32')->nth(1) == undef + NetAddr::IP->new('10/31')->nth(0) == undef + NetAddr::IP->new('10/31')->nth(1) == 10.0.0.1/31 + NetAddr::IP->new('10/30')->nth(0) == undef + NetAddr::IP->new('10/30')->nth(1) == 10.0.0.1/30 + NetAddr::IP->new('10/30')->nth(2) == 10.0.0.2/30 + NetAddr::IP->new('10/30')->nth(3) == 10.0.0.3/30 + + Note that in each case, the broadcast address is represented in the + output set and that the 'zero'th index is alway undef except for a + point-to-point /31 or /127 network where there are exactly two + addresses in the network. + + new behavior: + NetAddr::IP->new('10/32')->nth(0) == 10.0.0.0/32 + NetAddr::IP->new('10.1/32'->nth(0) == 10.0.0.1/32 + NetAddr::IP->new('10/31')->nth(0) == 10.0.0.0/32 + NetAddr::IP->new('10/31')->nth(1) == 10.0.0.1/32 + NetAddr::IP->new('10/30')->nth(0) == 10.0.0.1/30 + NetAddr::IP->new('10/30')->nth(1) == 10.0.0.2/30 + NetAddr::IP->new('10/30')->nth(2) == undef + + Note that a /32 net always has 1 usable address while a /31 has + exactly two usable addresses for point-to-point addressing. The first + index (0) returns the address immediately following the network + address except for a /31 or /127 when it return the network address. + + * '->num()' + + As of version 4.42 of NetAddr::IP and version 1.27 of + NetAddr::IP::Lite a /31 and /127 with return a net *num* value of 2 + instead of 0 (zero) for point-to-point networks. + + Version 4.00 of NetAddr::IP and version 1.00 of NetAddr::IP::Lite + return the number of usable IP addresses within the subnet, not + counting the broadcast or network address. + + Previous versions worked only for ipV4 addresses, returned a maximum + span of 2**32 and returned the number of IP addresses not counting + the broadcast address. (one greater than the new behavior) + + To use the old behavior for '->nth($index)' and '->num()': + + use NetAddr::IP::Lite qw(:old_nth); + + WARNING: + + NetAddr::IP will calculate and return a numeric string for network + ranges as large as 2**128. These values are TEXT strings and perl can + treat them as integers for numeric calculations. + + Perl on 32 bit platforms only handles integer numbers up to 2**32 and + on 64 bit platforms to 2**64. + + If you wish to manipulate numeric strings returned by NetAddr::IP + that are larger than 2**32 or 2**64, respectively, you must load + additional modules such as Math::BigInt, bignum or some similar + package to do the integer math. + + * '->re()' + + Returns a Perl regular expression that will match an IP address + within the given subnet. Defaults to ipV4 notation. Will return an + ipV6 regex if the address in not in ipV4 space. + + * '->re6()' + + Returns a Perl regular expression that will match an IP address + within the given subnet. Always returns an ipV6 regex. %prep %setup -q -n %{cpan_name}-%{version} %build -%{__perl} Makefile.PL INSTALLDIRS=vendor OPTIMIZE="$RPM_OPT_FLAGS" +%{__perl} Makefile.PL INSTALLDIRS=vendor OPTIMIZE="%{optflags}" %{__make} %{?_smp_mflags} %check @@ -64,10 +638,10 @@ Authors: %perl_gen_filelist %clean -%{__rm} -rf $RPM_BUILD_ROOT +%{__rm} -rf %{buildroot} %files -f %{name}.files -%defattr(-,root,root,-) -%doc Changes README TODO docs/rfc1884.txt +%defattr(644,root,root,755) +%doc Changes README TODO %changelog