unixdev.net


Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (Debian-5.0)
Page:
Section:
Apropos / Subsearch:
optional field

NetAddr::IP::UtilPP(3pUser Contributed Perl DocumentatNetAddr::IP::UtilPP(3pm)



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

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

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

         $rv = hasbits($bits128);
         $rv = isIPv4($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   $rv = isIPv4($bits128);

           This function returns true if there are no on bits present in the
           IPv6 portion of the 128 bit string and false otherwise.

       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   ($cidr,$spurious) = 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
               isIPv4
               shiftleft
               addconst
               add128
               sub128
               notcontiguous
               ipv4to6
               mask4to6
               ipanyto6
               maskanyto6
               ipv6to4
               bin2bcd
               bcd2bin
               comp128
               bin2bcdn
               bcdn2txt
               bcdn2bin
               simple_pack

AUTHOR
       Michael Robinton <michaelATbizsystems.com>

COPYRIGHT
       Copyright 2006 - 2007, Michael Robinton <michaelATbizsystems.com>

       This program is free software; you can redistribute it and/or modify it
       under the terms of the GNU General Public License (except as noted
       otherwise in individuals sub modules)  published by the Free Software
       Foundation; either version 2 of the License, or (at your option) any
       later version.

       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 the GNU
       General Public License for more details.

       You should have received a copy of the GNU General Public License along
       with this program; if not, write to the Free Software Foundation, Inc.,
       59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

AUTHOR
       Michael Robinton <michaelATbizsystems.com>



perl v5.10.0                      2007-06-06          NetAddr::IP::UtilPP(3pm)