NetAddr::IP::UtilPP(3pm)       User Contributed Perl Documentation       NetAddr::IP::UtilPP(3pm)



NAME
       NetAddr::IP::UtilPP -- pure Perl functions for NetAddr::IP::Util

SYNOPSIS
         use NetAddr::IP::UtilPP qw(
               hasbits
               shiftleft
               addconst
               add128
               sub128
               notcontiguous
               ipv4to6
               mask4to6
               ipanyto6
               maskanyto6
               ipv6to4
               bin2bcd
               bcd2bin
         );

         use NetAddr::IP::UtilPP qw(:all)

         $rv = hasbits($bits128);
         $bitsX2 = shiftleft($bits128,$n);
         $carry = addconst($ipv6naddr,$signed_32con);
         ($carry,$ipv6naddr)=addconst($ipv6naddr,$signed_32con);
         $carry = add128($ipv6naddr1,$ipv6naddr2);
         ($carry,$ipv6naddr)=add128($ipv6naddr1,$ipv6naddr2);
         $carry = sub128($ipv6naddr1,$ipv6naddr2);
         ($spurious,$cidr) = notcontiguous($mask128);
         ($carry,$ipv6naddr)=sub128($ipv6naddr1,$ipv6naddr2);
         $ipv6naddr = ipv4to6($netaddr);
         $ipv6naddr = mask4to6($netaddr);
         $ipv6naddr = ipanyto6($netaddr);
         $ipv6naddr = maskanyto6($netaddr);
         $netaddr = ipv6to4($pv6naddr);
         $bcdtext = bin2bcd($bits128);
         $bits128 = bcd2bin($bcdtxt);

DESCRIPTION
       NetAddr::IP::UtilPP provides pure Perl functions for NetAddr::IP::Util

       ·   $rv = hasbits($bits128);

           This function returns true if there are one's present in the 128 bit string and false
           if all the bits are zero.

             i.e.  if (hasbits($bits128)) {
                     &do_something;
                   }

             or    if (hasbits($bits128 & $mask128) {
                     &do_something;
                   }

           This allows the implementation of logical functions of the form of:

                   if ($bits128 & $mask128) {
                       ...

             input:        128 bit IPv6 string
             returns:      true if any bits are present

       ·   $bitsXn = shiftleft($bits128,$n);

             input:        128 bit string variable,
                           number of shifts [optional]
             returns:      bits X n shifts

             NOTE: input bits are returned
                   if $n is not specified

       ·   addconst($ipv6naddr,$signed_32con);

           Add a signed constant to a 128 bit string variable.

             input:        128 bit IPv6 string,
                           signed 32 bit integer
             returns:  scalar      carry
                       array       (carry, result)

       ·   add128($ipv6naddr1,$ipv6naddr2);

           Add two 128 bit string variables.

             input:        128 bit string var1,
                           128 bit string var2
             returns:  scalar      carry
                       array       (carry, result)

       ·   sub128($ipv6naddr1,$ipv6naddr2);

           Subtract two 128 bit string variables.

             input:        128 bit string var1,
                           128 bit string var2
             returns:  scalar      carry
                       array       (carry, result)

           Note: The carry from this operation is the result of adding the one's complement of
           ARG2 +1 to the ARG1. It is logically NOT borrow.

                   i.e.    if ARG1 >= ARG2 then carry = 1
                   or      if ARG1  < ARG2 then carry = 0

       ·   ($spurious,$cidr) = notcontiguous($mask128);

           This function counts the bit positions remaining in the mask when the rightmost '0's
           are removed.

                   input:  128 bit netmask
                   returns true if there are spurious
                               zero bits remaining in the
                               mask, false if the mask is
                               contiguous one's,
                           128 bit cidr

       ·   $ipv6naddr = ipv4to6($netaddr);

           Convert an ipv4 network address into an ipv6 network address.

             input:        32 bit network address
             returns:      128 bit network address

       ·   $ipv6naddr = mask4to6($netaddr);

           Convert an ipv4 netowrk address into an ipv6 network mask.

             input:        32 bit network/mask address
             returns:      128 bit network/mask address

           NOTE: returns the high 96 bits as one's

       ·   $ipv6naddr = ipanyto6($netaddr);

           Similar to ipv4to6 except that this function takes either an IPv4 or IPv6 input and
           always returns a 128 bit IPv6 network address.

             input:        32 or 128 bit network address
             returns:      128 bit network address

       ·   $ipv6naddr = maskanyto6($netaddr);

           Similar to mask4to6 except that this function takes either an IPv4 or IPv6 netmask and
           always returns a 128 bit IPv6 netmask.

             input:        32 or 128 bit network mask
             returns:      128 bit network mask

       ·   $netaddr = ipv6to4($pv6naddr);

           Truncate the upper 96 bits of a 128 bit address and return the lower 32 bits. Returns
           an IPv4 address as returned by inet_aton.

             input:        128 bit network address
             returns:      32 bit inet_aton network address

       ·   $bcdtext = bin2bcd($bits128);

           Convert a 128 bit binary string into binary coded decimal text digits.

             input:        128 bit string variable
             returns:      string of bcd text digits

       ·   $bits128 = bcd2bin($bcdtxt);

           Convert a bcd text string to 128 bit string variable

             input:        string of bcd text digits
             returns:      128 bit string variable

EXPORT_OK
               hasbits
               shiftleft
               addconst
               add128
               sub128
               notcontiguous
               ipv4to6
               mask4to6
               ipanyto6
               maskanyto6
               ipv6to4
               bin2bcd
               bcd2bin
               comp128
               bin2bcdn
               bcdn2txt
               bcdn2bin
               simple_pack
               threads

AUTHOR
       Michael Robinton <michael AT bizsystems.com>

COPYRIGHT
       Copyright 2003 - 2012, Michael Robinton <michael AT bizsystems.com>

       All rights reserved.

       This program is free software; you can redistribute it and/or modify it under the terms of
       either:

         a) the GNU General Public License as published by the Free
         Software Foundation; either version 2, or (at your option) any
         later version, or

         b) the "Artistic License" which comes with this distribution.

       This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
       without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
       See either the GNU General Public License or the Artistic License for more details.

       You should have received a copy of the Artistic License with this distribution, in the
       file named "Artistic".  If not, I'll be glad to provide one.

       You should also have received a copy of the GNU General Public License along with this
       program in the file named "Copying". If not, write to the

               Free Software Foundation, Inc.,
               51 Franklin Street, Fifth Floor
               Boston, MA 02110-1301 USA

       or visit their web page on the internet at:

               http://www.gnu.org/copyleft/gpl.html.

AUTHOR
       Michael Robinton <michael AT bizsystems.com>



perl v5.20.0                                2012-08-10                   NetAddr::IP::UtilPP(3pm)