Opcje wyszukiwania podręcznika man:
Lista stron man zaczynających się od znaku:
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Y   Z   ALPHA   NUM   OTHER   ALL
IP(3pm)               User Contributed Perl Documentation              IP(3pm)

       Net::IP - Perl extension for manipulating IPv4/IPv6 addresses

         use Net::IP;

         my $ip = new Net::IP ('193.0.1/24') or die (Net::IP::Error());
         print ("IP  : ".$ip->ip()."\n");
         print ("Sho : ".$ip->short()."\n");
         print ("Bin : ".$ip->binip()."\n");
         print ("Int : ".$ip->intip()."\n");
         print ("Mask: ".$ip->mask()."\n");
         print ("Last: ".$ip->last_ip()."\n");
         print ("Len : ".$ip->prefixlen()."\n");
         print ("Size: ".$ip->size()."\n");
         print ("Type: ".$ip->iptype()."\n");
         print ("Rev:  ".$ip->reverse_ip()."\n");

       This module provides functions to deal with IPv4/IPv6 addresses. The
       module can be used as a class, allowing the user to instantiate IP
       objects, which can be single IP addresses, prefixes, or ranges of
       addresses. There is also a procedural way of accessing most of the
       functions. Most subroutines can take either IPv4 or IPv6 addresses

       Object Creation

       A Net::IP object can be created from a single IP address:

         $ip = new Net::IP ('') || die ...

       Or from a Classless Prefix (a /24 prefix is equivalent to a C class):

         $ip = new Net::IP ('195.114.80/24') || die ...

       Or from a range of addresses:

         $ip = new Net::IP (' -') || die ...

       Or from a address plus a number:

         $ip = new Net::IP (' + 255') || die ...

       The new() function accepts IPv4 and IPv6 addresses:

         $ip = new Net::IP ('dead:beef::/32') || die ...

       Optionnaly, the function can be passed the version of the IP. Other-
       wise, it tries to guess what the version is (see _is_ipv4() and

         $ip = new Net::IP ('195/8',4); # Class A

       Most of these methods are front-ends for the real functions, which use
       a procedural interface. Most functions return undef on failure, and a
       true value on success. A detailed description of the procedural inter-
       face is provided below.


       Set an IP address in an existing IP object. This method has the same
       functionality as the new() method, except that it reuses an existing
       object to store the new IP.


       Like new(), set() takes two arguments - a string used to build an IP
       address, prefix, or range, and optionally, the IP version of the con-
       sidered address.

       It returns an IP object on success, and undef on failure.


       Return the current object error string. The error string is set when-
       ever one of the methods produces an error. Also, a global, class-wide
       Error() function is avaliable.

       "warn ($ip->error());"


       Return the current object error number. The error number is set when-
       ever one of the methods produces an error. Also, a global $ERRNO vari-
       able is set when an error is produced.

       "warn ($ip->errno());"


       Return the IP address (or first IP of the prefix or range) in quad for-
       mat, as a string.

       "print ($ip->ip());"


       Return the IP address as a binary string of 0s and 1s.

       "print ($ip->binip());"


       Return the length in bits of the current prefix.

       "print ($ip->prefixlen());"


       Return the version of the current IP object (4 or 6).

       "print ($ip->version());"


       Return the number of IP addresses in the current prefix or range.  Use
       of this function requires Math::BigInt.

       "print ($ip->size());"


       Return the binary mask of the current prefix, if applicable.

       "print ($ip->binmask());"


       Return the mask in quad format of the current prefix.

       "print ($ip->mask());"


       Return the full prefix (ip+prefix length) in quad (standard) format.

       "print ($ip->prefix());"


       Print the IP object (IP/Prefix or First - Last)

       "print ($ip->print());"


       Convert the IP in integer format and return it as a Math::BigInt

       "print ($ip->intip());"


       Return the IP in hex format

       "print ($ip->hexip());"


       Return the mask in hex format

       "print ($ip->hexmask());"


       Return the IP in short format:      IPv4 addresses: 194.5/16      IPv6
       addresses: ab32:f000::

       "print ($ip->short());"


       Return the IP Type - this describes the type of an IP (Public, Private,
       Reserved, etc.)

       "print ($ip->iptype());"


       Return the reverse IP for a given IP address (in.addr. format).

       "print ($ip->reserve_ip());"


       Return the last IP of a prefix/range in quad format.

       "print ($ip->last_ip());"


       Return the last IP of a prefix/range in binary format.

       "print ($ip->last_bin());"


       Return the last IP of a prefix/range in integer format.

       "print ($ip->last_int());"


       This function finds all the prefixes that can be found between the two
       addresses of a range. The function returns a list of prefixes.

       "@list = $ip->find_prefixes($other_ip));"


       Binary comparaison of two IP objects. The function takes an operation
       and an IP object as arguments. It returns a boolean value.

       The operation can be one of: lt: less than (smaller than) le: smaller
       or equal to gt: greater than ge: greater or equal to

       "if ($ip->bincomp('lt',$ip2) {...}"


       Binary addition of two IP objects. The value returned is an IP object.

       "my $sum = $ip->binadd($ip2);"


       Aggregate 2 IPs - Append one range/prefix of IPs to another. The last
       address of the first range must be the one immediately preceding the
       first address of the second range. A new IP object is returned.

       "my $total = $ip->aggregate($ip2);"


       Check if two IP ranges/prefixes overlap each other. The value returned
       by the function should be one of:      $IP_PARTIAL_OVERLAP (ranges
       overlap)      $IP_NO_OVERLAP      (no overlap)      $IP_A_IN_B_OVERLAP
       (range2 contains range1)      $IP_B_IN_A_OVERLAP  (range1 contains
       range2)      $IP_IDENTICAL       (ranges are identical)      undef

       "if ($ip->overlaps($ip2)==$IP_A_IN_B_OVERLAP) {...};"


       The "+" operator is overloaded in order to allow looping though a whole
       range of IP addresses:

         my $ip = new Net::IP (' -') || die;
         # Loop
         do {
             print $ip->ip(), "\n";
         } while (++$ip);

       The ++ operator returns undef when the last address of the range is


       Return IP authority information from the IP::Authority module

       "$auth = ip-"auth ();>

       Note: IPv4 only

       These functions do the real work in the module. Like the OO methods,
       most of these return undef on failure. In order to access error codes
       and strings, instead of using $ip->error() and $ip->errno(), use the
       global functions "Error()" and "Errno()".

       The functions of the procedural interface are not exported by default.
       In order to import these functions, you need to modify the use state-
       ment for the module:

       "use Net::IP qw(:PROC);"


       Returns the error string corresponding to the last error generated in
       the module. This is also useful for the OO interface, as if the new()
       function fails, we cannot call $ip->error() and so we have to use

       warn Error();


       Returns a numeric error code corresponding to the error string returned
       by Error.


       Transform an IP address into a bit string.

           Params  : IP address, IP version
           Returns : binary IP string on success, undef otherwise

       "$binip = ip_iptobin ($ip,6);"


       Transform a bit string into an IP address

           Params  : binary IP, IP version
           Returns : IP address on success, undef otherwise

       "$ip = ip_bintoip ($binip,6);"


       Transform a bit string into a BigInt.

           Params  : binary IP
           Returns : BigInt

       "$bigint = new Math::BigInt (ip_bintoint($binip));"


       Transform a BigInt into a bit string.  Warning: sets warnings ("-w")
       off. This is necessary because Math::BigInt is not compliant.

           Params  : BigInt, IP version
           Returns : binary IP

       "$binip = ip_inttobin ($bigint);"


       Try to guess the IP version of an IP address.

           Params  : IP address
           Returns : 4, 6, undef(unable to determine)

       "$version = ip_get_version ($ip)"


       Check if an IP address is of type 4.

           Params  : IP address
           Returns : 1 (yes) or 0 (no)

       "ip_is_ipv4($ip) and print "$ip is IPv4";"


       Check if an IP address is of type 6.

           Params            : IP address
           Returns           : 1 (yes) or 0 (no)

       "ip_is_ipv6($ip) and print "$ip is IPv6";"


       Expand an IP address from compact notation.

           Params  : IP address, IP version
           Returns : expanded IP address or undef on failure

       "$ip = ip_expand_address ($ip,4);"


       Get IP mask from prefix length.

           Params  : Prefix length, IP version
           Returns : Binary Mask

       "$mask = ip_get_mask ($len,6);"


       Return the last binary address of a prefix.

           Params  : First binary IP, prefix length, IP version
           Returns : Binary IP

       "$lastbin = ip_last_address_bin ($ip,$len,6);"


       Split a prefix into IP and prefix length.  If it was passed a simple
       IP, it just returns it.

           Params  : Prefix
           Returns : IP, optionnaly length of prefix

       "($ip,$len) = ip_splitprefix ($prefix)"


       Get a range of IPs from a prefix.

           Params  : Prefix, IP version
           Returns : First IP, last IP

       "($ip1,$ip2) = ip_prefix_to_range ($prefix,6);"


       Compare binary Ips with <, >, <=, >=.
        Operators are lt(<), le(<=), gt(>), and ge(>=)

           Params  : First binary IP, operator, Last binary IP
           Returns : 1 (yes), 0 (no), or undef (problem)

       "ip_bincomp ($ip1,'lt',$ip2) == 1 or do {}"


       Add two binary IPs.

           Params  : First binary IP, Last binary IP
           Returns : Binary sum or undef (problem)

       "$binip = ip_binadd ($bin1,$bin2);"


       Get the prefix length for a given range of 2 IPs.

           Params  : First binary IP, Last binary IP
           Returns : Length of prefix or undef (problem)

       "$len = ip_get_prefix_length ($ip1,$ip2);"


       Return all prefixes between two IPs.

           Params  : First IP, Last IP, IP version
           Returns : List of Prefixes or undef (problem)

       The prefixes returned have the form q.q.q.q/nn.

       "@prefix = ip_range_to_prefix ($ip1,$ip2,6);"


       Compress an IPv4 Prefix.

           Params  : IP, Prefix length
           Returns : Compressed Prefix

       "$ip = ip_compress_v4_prefix ($ip, $len);"


       Compress an IPv6 address. Just returns the IP if it is an IPv4.

           Params  : IP, IP version
           Returns : Compressed IP or undef (problem)

       "$ip = ip_compress_adress ($ip, $version);"


       Check if two ranges of IPs overlap.

           Params  : Four binary IPs (begin of range 1,end1,begin2,end2), IP version
               $IP_PARTIAL_OVERLAP (ranges overlap)
               $IP_NO_OVERLAP      (no overlap)
               $IP_A_IN_B_OVERLAP  (range2 contains range1)
               $IP_B_IN_A_OVERLAP  (range1 contains range2)
               $IP_IDENTICAL       (ranges are identical)
               undef               (problem)

       "(ip_is_overlap($rb1,$re1,$rb2,$re2,4) eq $IP_A_IN_B_OVERLAP) and do


       Get an IPv4 embedded in an IPv6 address

           Params  : IPv6
           Returns : IPv4 string or undef (not found)

       "$ip4 = ip_get_embedded($ip6);"


       Check the validity of a binary IP mask

           Params  : Mask
           Returns : 1 or undef (invalid)

       "ip_check_mask($binmask) or do {};"

       Checks if mask has only 1s followed by 0s.


       Aggregate 2 ranges of binary IPs

           Params  : 1st range (1st IP, Last IP), last range (1st IP, last IP), IP version
           Returns : prefix or undef (invalid)

       "$prefix = ip_aggregate ($bip1,$eip1,$bip2,$eip2) || die ..."


       Return the type of an IP (Public, Private, Reserved)

           Params  : IP to test, IP version
           Returns : type or undef (invalid)

       "$type = ip_iptype ($ip);"


       Check the validity of a prefix

           Params  : binary IP, length of prefix, IP version
           Returns : 1 or undef (invalid)

       Checks if the variant part of a prefix only has 0s, and the length is

       "ip_check_prefix ($ip,$len,$ipv) or do {};"


       Get a reverse name from a prefix

           Params  : IP, length of prefix, IP version
           Returns : Reverse name or undef (error)

       "$reverse = ip_reverse ($ip);"


       Normalize data to a range/prefix of IP addresses

           Params  : Data String (Single IP, Range, Prefix)
           Returns : ip1, ip2 (if range/prefix) or undef (error)

       "($ip1,$ip2) = ip_normalize ($data);"


       Return IP authority information from the IP::Authority module

           Params  : IP, version
           Returns : Auth info (RI for RIPE, AR for ARIN, etc)

       "$auth = ip_auth ($ip,4);"

       Note: IPv4 only

       The Math::BigInt library is needed for functions that use integers.
       These are ip_inttobin, ip_bintoint, and the size method. In a next ver-
       sion, Math::BigInt will become optionnal.

       Manuel Valente <>.

       Original IPv4 code by Monica Cortes Sack <>.

       Original IPv6 code by Lee Wilmot <>.


       perl(1), IP::Authority

perl v5.8.8                       2006-05-22                           IP(3pm)

Time taken: 0.00022 seconds

Created with the man page lookup class by Andrew Collington,