- initial package 4.042

* a lot of changes, see Changes

OBS-URL: https://build.opensuse.org/package/show/devel:languages:perl/perl-NetAddr-IP?expand=0&rev=16

NetAddr-IP-4.030.tar.bz2

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e71f61a49051459a33c989a8a77ddb8bed683c9fa01ecda93b18868c7bcb49b3
-size 115022

NetAddr-IP-4.042.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c261d0bc46f3a776772c6d83646caa92b7ffd79d6f613b79d5e21f6796291138
+size 148775

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
 

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
+Version:        4.042
-Summary:        Manages IPv4 and IPv6 addresses and subnets
-Version:        4.030
 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
+Group:          Development/Libraries/Perl
-Source:         %{cpan_name}-%{version}.tar.bz2
+#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}
+%{perl_requires}
-BuildRequires:  perl(Test::Pod)
-BuildRequires:  perl(Pod::Coverage)
-%endif
 
 %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:
+The internal representation of all IP objects is in 128 bit IPv6 notation.
---------
+IPv4 and IPv6 objects may be freely mixed.
-    Luis E. Munoz <luismunoz@cpan.org>
+
+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<bits> 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,-)
+%defattr(644,root,root,755)
-%doc Changes README TODO docs/rfc1884.txt
+%doc Changes README TODO
 
 %changelog