Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
IPv6::Address(3)      User Contributed Perl Documentation     IPv6::Address(3)

NAME
       IPv6::Address - IPv6 Address Manipulation Library

VERSION
       version 0.208

SYNOPSIS
	use IPv6::Address;

	my $ipv6 = IPv6::Address->new('2001:648:2000::/48');

	$ipv6->contains('2001:648:2000::/64'); #true

	say $ipv6->to_string;
	say $ipv6->string; # Same as previous
	say $ipv6; # Same as previous

	say $ipv6->string(nocompress=>1); # do not compress using the :: notation
	say $ipv6->string(ipv4=>1); #print the last 32 bits as an IPv4 address

	$ipv6->addr_string; # Returns '2001:648:2000::'

	$ipv6->split(4); # Split the prefix into 2^4 smaller prefixes. Returns a list.

	$ipv6->apply_mask; # Apply the mask to the address. All	bits beyond the	mask length become 0.

	$ipv6->first_address;

	$ipv6->last_address;

	$a->enumerate_with_offset( 5 , 64 ); #returns 2001:648:2000:4::/64

DESCRIPTION
       A pure Perl IPv6	address	manipulation library. Emphasis on manipulation
       of prefixes and addresses. Very easy to understand and modify. The
       internal	representation of an IPv6::Address is a	blessed	hash with two
       keys, a prefix length (0-128 obviously) and a 128-bit string. A
       multitude of methods to do various tasks	is provided.

   Methods
       "new( ipv6_string )"
		   Takes a string representation of an IPv6 address and
		   creates a corresponding IPv6::Address object.

       "raw_new( bitstr, length	)"
		   Creates a new IPv6::Address out of a	bitstring and a	prefix
		   length. The bitstring must be binary, please	do not use a
		   '0' or '1' character	string.

       "get_bitstr"
		   Returns the bitstr of the object.

       "get_prefixlen"
		   Returns the prefix length of	the address.

       "get_mask_bitstr(length)"
		   Returns a 128-bit string with the first prefix-length bits
		   equal to 1, rest equal to 0.	Essentially takes the prefix
		   length of the object	and returns a corresponding bit	mask.

       "get_masked_address_bitstr"
		   Returns the bitstring, after	zeroing	out all	the bits after
		   the prefix length.  Essentially applies the prefix mask to
		   the address.

       "generate_bitstr( number	)"
		   Not a method, returns 128-bit string, first n-items are 1,
		   rest	is 0.

       "bitstr_and( bitstr1 , bitstr2 )"
		   Not a method, AND's two bitstrings, returns result.

       "bitstr_or( bitstr1 , bitstr2)"
		   Not a method, OR's two bitstrings, returns result.

       "bitstr_not( bitstr )"
		   Not a method, inverts a bitstring.

       "from_str( string_bitstring )"
		   Not a method, takes a string	of characters 0	or 1, returns
		   corresponding binary	bitstring.  Please do not use more
		   than	128 characters,	rest will be ignored.

       "to_str(	bitstring )"
		   Not a method, takes a binary	bitstring, returns a string
		   composed of 0's and 1's. Please supply bitstrings of	max.
		   128 bits, rest of the bits will be ignored.

       "contains( other_address	)"
		   This	method takes an	argument which is either an
		   IPv6::Address or a plain string that	can be promoted	to a
		   valid IPv6::Address,	and tests whether the object contains
		   it. Obviously returns true or false.

       "addr_string"
		   Returns the address part of the IPv6::Address. Using	the
		   option ipv4=>1 like

		    $a->addr_string(ipv4=>1)

		   will	make the last 32-bits appear as	an IPv4	address. Also,
		   using nocompress=>1 like

		    $a->addr_string( nocompress	=> 1 )

		   will	prevent	the string from	containing a '::' part.	So it
		   will	be 8 parts separated by	':' colons.

       "string"	   Returns the full IPv6 address, with the prefix in its end.

       "to_string" Used	internally by the overload module.

       "split( exponent	, target_length	)"
		   Splits the address to the order of two of the number	given
		   as first argument.  Example:	if argument is 3, 2^3=8,
		   address is split into 8 parts. The final parts have prefix
		   length equal	to the target_length specified in the second
		   argument.

       "apply_mask"
		   Applies the prefix length mask to the address. Does not
		   return anything. Works on $self.  WARNING:This will alter
		   the object.

       "first_address"
		   Returns the first address of	the prefix that	is represented
		   by the object. E.g.	consider 2001:648:2000::1234/64. First
		   address will	be 2001:648:2000::/64.

       "last_address"
		   Returns the last address of the prefix that is represented
		   by the object. E.g.	consider 2001:648:2000::1234/64. Last
		   address will	be 2001:648:2000::ffff:ffff:ffff:ffff/64.

       "is_unspecified"	, "is_loopback"	, "is_multicast"
		   Returns true	or false depending on whether the address
		   falls into the corresponding	category stated	by the method
		   name. E.g.

		    IPv6::Address->new('::1')->is_loopback # returns true

       "ipv4_to_binarray"
		   Not a method, takes an IPv4 address,	returns	a character
		   string consisting of	32 characters that are 0 or 1. Used
		   internally, not too useful for the end user.

       "enumerate_with_IPv4( ipv4, mask	)"
		   Takes an IPv4 address and uses a part of it to enumerate
		   inside the Ipv6 prefix of the object. E.g.

		    IPv6::Address->new('2001:648:2001::/48')->enumerate_with_IPv4('0.0.0.1',0x0000ffff)	#will yield 2001:648::2001:0001::/64

		   The return value will be a new IPv6::Address	object,	so the
		   original object remains intact. The part that will be used
		   as an offset	is extracted from the ipv4 by using the	mask.

       "enumerate_with_offset( offset, desired_length )"
		   Takes a non-negative	integer	offset and returns a prefix
		   whose relative position inside the object is	defined	by the
		   offset. The prefix length of	the result is defined by the
		   second argument. E.g.

		    IPv6::Address->new('2001:648:2000::/48')->enumerate_with_offset( 5 , 64 ) #2001:648:2000:4::/64

       "increment( offset )"
		   Increments the IPv6::Address	object by offset. Offsets
		   larger than 2^32-1 are not acceptable. This method is
		   probably not	too useful, but	is provided for	completeness.

       "nxx_parts(unpack_format)"
		   Takes the bitstring of the address and unpacks it using the
		   first argument.  Internal use mostly.

       "n16_parts" Splits the address into an 8-item array of unsigned short
		   integers. Network byte order	is implied, a short integer is
		   16-bits long.

       "n16_parts" Splits the address into an 4-item array of unsigned long
		   integers. Network byte order	is implied, a long integer is
		   32-bits long.

       "n_cmp( a , b )"
		   Takes two 128-bit bitstr arguments, compares	them and
		   returns the result as -1, 0 or 1. The semantics are the
		   same	as that	of the spaceship operator <=>.

		   This	method will overload the <=> operator for
		   IPv6::Address objects, so comparing IPv6::Address objects
		   like	they were integers produces the	correct	results.

       "n_sort(	array )"
		   Sorts an array of bitstrs using the n_cmp function.

       "radius_string"
		   Returns a string suitable to	be returned as an IPv6 Radius
		   AV-pair. See	RFC 3162 for an	explanation of the format.

AUTHOR
       Athanasios Douitsis "<aduitsis@cpan.org>"

SUPPORT
       Please open a ticket at <https://github.com/aduitsis/IPv6-Address>.

COPYRIGHT & LICENSE
       Copyright 2008-2015 Athanasios Douitsis,	all rights reserved.

       This program is free software; you can use it under the terms of
       Artistic	License	2.0 which can be found at
       http://www.perlfoundation.org/artistic_license_2_0

perl v5.32.0			  2020-08-10		      IPv6::Address(3)

NAME | VERSION | SYNOPSIS | DESCRIPTION | AUTHOR | SUPPORT | COPYRIGHT & LICENSE

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=IPv6::Address&sektion=3&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help