NetAddr::IP::UtilPP(category21-suse.html) - phpMan

NetAddr::IP::UtilPP(3)User Contributed Perl DocumentatioNetAddr::IP::UtilPP(3)

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
       o   $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
       o   $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
       o   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)
       o   add128($ipv6naddr1,$ipv6naddr2);
           Add two 128 bit string variables.
             input:        128 bit string var1,
                           128 bit string var2
             returns:  scalar      carry
                       array       (carry, result)
       o   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
       o   ($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
       o   $ipv6naddr = ipv4to6($netaddr);
           Convert an ipv4 network address into an ipv6 network address.
             input:        32 bit network address
             returns:      128 bit network address
       o   $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
       o   $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
       o   $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
       o   $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
       o   $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
       o   $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.16.3                      2012-08-10            NetAddr::IP::UtilPP(3)