inet::IPv6Address Class Reference

Stores a 128-bit IPv6 address in an efficient way. More...

#include <IPv6Address.h>

Public Types
enum	Scope {   UNSPECIFIED, LOOPBACK, MULTICAST, LINK,   SITE, GLOBAL }
	IPv6 address scope (RFC 3513) More...

Public Member Functions
	IPv6Address ()
	Constructor. More...
	IPv6Address (uint64 hi, uint64 lo)
	Constructs an IPv6 address from two 64-bit integers. More...
	IPv6Address (uint32 segment0, uint32 segment1, uint32 segment2, uint32 segment3)
	Constructs an IPv6 address from four 32-bit integers. More...
	IPv6Address (const char *addr)
	Constructor. More...
bool	operator< (const IPv6Address &addr) const
bool	operator> (const IPv6Address &addr) const
bool	operator== (const IPv6Address &addr) const
bool	operator!= (const IPv6Address &addr) const
int	compare (const IPv6Address &addr) const
	Returns -1, 0 or 1. More...
bool	tryParse (const char *addr)
	Tries parsing an IPv6 address string into the object. More...
bool	tryParseAddrWithPrefix (const char *addr, int &prefixLen)
	Expects a string in the "<address>/<prefixlength>" syntax, parses the address into the object (see tryParse(), and returns the prefix length (a 0..128 integer) in the second argument. More...
void	set (const char *addr)
	Sets the IPv6 address. More...
std::string	str () const
	Returns the textual representation of the address in the standard notation. More...
void	set (uint32 d0, uint32 d1, uint32 d2, uint32 d3)
	Sets the IPv6 address from four 32-bit integers. More...
uint32 *	words ()
	Returns a pointer to the internal binary representation of the address: four 32-bit words, most significant word first. More...
const uint32 *	words () const
	Returns a pointer to the internal binary representation of the address: four 32-bit words, most significant word first. More...
Scope	getScope () const
	Get the IPv6 address scope. More...
IPv6Address	getPrefix (int prefixLength) const
	Get the IPv6 first prefixLength bits of the address, with the rest set to zero. More...
IPv6Address	getSuffix (int prefixLength) const
	Get the last 128-prefixLength bits of the address, with the first bits set to zero. More...
const IPv6Address &	setPrefix (const IPv6Address &fromAddr, int prefixLength)
	Overwrites the first prefixLength bits of the address with the bits from the address passed as argument. More...
const IPv6Address &	setSuffix (const IPv6Address &fromAddr, int prefixLength)
	Overwrites the last 128-prefixLength bits of the address with the bits from address passed as argument. More...
IPv6Address	formSolicitedNodeMulticastAddress () const
	Returns the solicited-node multicast address for this address. More...
bool	isSolicitedNodeMulticastAddress () const
IPv6Address	formSubnetRouterAnycastAddress (int prefixLength) const
	Returns the subnet-router anycast address for this address by setting its suffix (the last 128-prefixLength bits) to all-zeroes. More...
bool	matches (const IPv6Address &prefix, int prefixLength) const
	Returns true if the address matches the given prefix. More...
bool	isUnspecified () const
	Check if the IPv6 Address is undefined. More...
bool	isMulticast () const
	Utility function based on getScope() More...
bool	isUnicast () const
	Utility function based on getScope() More...
bool	isLoopback () const
	Utility function based on getScope() More...
bool	isLinkLocal () const
	Utility function based on getScope() More...
bool	isSiteLocal () const
	Utility function based on getScope() More...
bool	isGlobal () const
	Utility function based on getScope() More...
int	getMulticastScope () const
	Get the 4-bit scope field of an IPv6 multicast address. More...

Static Public Member Functions
static const char *	scopeName (Scope s)
	Return the string representation of the given scope. More...
static void	constructMask (int prefixLength, uint32 *mask)
	Construct a 128-bit mask based on the prefix length. More...
static IPv6Address	constructMask (int prefixLength)
static IPv6Address	formLinkLocalAddress (const InterfaceToken &ident)
	Forms a link-local address using the given interface identifier. More...

Static Public Attributes
Predefined addresses
static const IPv6Address	UNSPECIFIED_ADDRESS
	The unspecified address. More...
static const IPv6Address	LOOPBACK_ADDRESS
	The loopback address. More...
static const IPv6Address	ALL_NODES_1
	All-nodes multicast address, scope 1 (interface-local) More...
static const IPv6Address	ALL_NODES_2
	All-nodes multicast address, scope 2 (link-local) More...
static const IPv6Address	ALL_ROUTERS_1
	All-routers multicast address, scope 1 (interface-local) More...
static const IPv6Address	ALL_ROUTERS_2
	All-routers multicast address, scope 2 (link-local) More...
static const IPv6Address	ALL_ROUTERS_5
	All-routers multicast address, scope 5 (site-local) More...
static const IPv6Address	SOLICITED_NODE_PREFIX
	The solicited-node multicast address prefix (prefix length = 104) More...
static const IPv6Address	LINKLOCAL_PREFIX
	The link-local prefix (fe80::) More...
static const IPv6Address	LL_MANET_ROUTERS
	Link-local MANET routers multicast address. More...

Protected Member Functions
bool	doTryParse (const char *&addr)

Private Attributes
uint32	d [4]

Detailed Description

Stores a 128-bit IPv6 address in an efficient way.

Complies to RFC 3513, "Internet Protocol Version 6 (IPv6) Addressing Architecture."

Member Enumeration Documentation

enum inet::IPv6Address::Scope

IPv6 address scope (RFC 3513)

Enumerator
UNSPECIFIED
LOOPBACK
MULTICAST
LINK
SITE
GLOBAL

               {
        UNSPECIFIED,
        LOOPBACK,
        MULTICAST,
        LINK,
        SITE,
        GLOBAL
    };

Constructor & Destructor Documentation

inet::IPv6Address::IPv6Address ( )

inline

Constructor.

Initializes the IPv6 address to ::0 (all-zeroes).

Referenced by getPrefix(), and getSuffix().

{ d[0] = d[1] = d[2] = d[3] = 0; }

inet::IPv6Address::IPv6Address ( uint64  hi, uint64  lo  )

inline

Constructs an IPv6 address from two 64-bit integers.

    {
        uint32 mask = 0xFFFFFFFF;
        d[0] = (hi >> 32) & mask;
        d[1] = hi & mask;
        d[2] = (lo >> 32) & mask;
        d[3] = lo & mask;
    }

inet::IPv6Address::IPv6Address ( uint32  segment0, uint32  segment1, uint32  segment2, uint32  segment3  )

inline

Constructs an IPv6 address from four 32-bit integers.

The most significant word should be passed in the first argument.

    {
        d[0] = segment0;
        d[1] = segment1;
        d[2] = segment2;
        d[3] = segment3;
    }

inet::IPv6Address::IPv6Address ( const char *  addr )

inlineexplicit

Constructor.

Sets the address from the given text representation. See documentation of tryParse() for supported syntax.

{ set(addr); }

Member Function Documentation

int inet::IPv6Address::compare ( const IPv6Address &  addr ) const

inline

Returns -1, 0 or 1.

    {
        return d[0] < addr.d[0] ? -1 : d[0] > addr.d[0] ? 1 :
               d[1] < addr.d[1] ? -1 : d[1] > addr.d[1] ? 1 :
               d[2] < addr.d[2] ? -1 : d[2] > addr.d[2] ? 1 :
               d[3] < addr.d[3] ? -1 : d[3] > addr.d[3] ? 1 : 0;
    }

void inet::IPv6Address::constructMask ( int  prefixLength, uint32 *  mask  )

static

Construct a 128-bit mask based on the prefix length.

Mask should point to an array of four 32-bit words, most significant word first.

Referenced by constructMask(), getPrefix(), getSuffix(), matches(), setPrefix(), and setSuffix().

{
    ASSERT(prefixLength >= 0 && prefixLength <= 128 && mask != nullptr);

    // create a mask based on the prefix length.
    if (prefixLength == 0) {
        mask[0] = mask[1] = mask[2] = mask[3] = 0x00000000;
    }
    else if (prefixLength <= 32) {
        int num_of_shifts = 32 - prefixLength;
        mask[0] = 0xFFFFFFFFU << num_of_shifts;
        mask[1] = 0x00000000;
        mask[2] = 0x00000000;
        mask[3] = 0x00000000;
    }
    else if (prefixLength <= 64) {
        int num_of_shifts = 64 - prefixLength;
        mask[0] = 0xFFFFFFFFU;
        mask[1] = 0xFFFFFFFFU << num_of_shifts;
        mask[2] = 0x00000000;
        mask[3] = 0x00000000;
    }
    else if (prefixLength <= 96) {
        int num_of_shifts = 96 - prefixLength;
        mask[0] = 0xFFFFFFFFU;
        mask[1] = 0xFFFFFFFFU;
        mask[2] = 0xFFFFFFFFU << num_of_shifts;
        mask[3] = 0x00000000;
    }
    else {
        int num_of_shifts = 128 - prefixLength;
        mask[0] = 0xFFFFFFFFU;
        mask[1] = 0xFFFFFFFFU;
        mask[2] = 0xFFFFFFFFU;
        mask[3] = 0xFFFFFFFFU << num_of_shifts;
    }
}

IPv6Address inet::IPv6Address::constructMask ( int  prefixLength )

static

{
    IPv6Address ret;
    constructMask(prefixLength, ret.d);
    return ret;
}

bool inet::IPv6Address::doTryParse ( const char *&  addr )

protected

Referenced by tryParse(), and tryParseAddrWithPrefix().

{
    if (!strcmp(addr, "<unspec>")) {
        addr += 8;
        d[0] = d[1] = d[2] = d[3] = 0;
        return true;
    }

    // parse and store 16-bit units
    uint16_t groups[8];
    int numGroups = parseGroups(addr, groups);

    // if address string contains "::", parse and store second half too
    if (*addr == ':' && *(addr + 1) == ':') {
        addr += 2;
        uint16_t suffixGroups[8];
        int numSuffixGroups = parseGroups(addr, suffixGroups);

        // merge suffixGroups[] into groups[]
        if (numGroups + numSuffixGroups > 8)
            return false; // too many
        for (int i = numGroups; i < 8; i++) {
            int j = i - 8 + numSuffixGroups;
            groups[i] = j < 0 ? 0 : suffixGroups[j];
        }
        numGroups = 8;
    }

    if (numGroups != 8)
        return false; // too few

    // copy groups to d[]
    for (unsigned int i = 0; i < 4; i++)
        d[i] = ((uint32_t)(groups[2 * i]) << 16) + groups[2 * i + 1];

    return true;
}

IPv6Address inet::IPv6Address::formLinkLocalAddress ( const InterfaceToken &  ident )

static

Forms a link-local address using the given interface identifier.

Referenced by inet::IPv6NeighbourDiscovery::assignLinkLocalAddress(), inet::IPv6RoutingTable::assignRequiredNodeAddresses(), and inet::FlatNetworkConfigurator6::configureAdvPrefixes().

{
    IPv6Address suffix(0, 0, ident.normal(), ident.low());
    IPv6Address linkLocalAddr = IPv6Address::LINKLOCAL_PREFIX;
    linkLocalAddr.setSuffix(suffix, 128 - ident.length());
    return linkLocalAddr;
}

IPv6Address inet::IPv6Address::formSolicitedNodeMulticastAddress ( ) const

inline

Returns the solicited-node multicast address for this address.

This function replaces the prefix with FF02:0:0:0:0:1:FF00:0/104.

Referenced by inet::IPv6NeighbourDiscovery::initiateAddressResolution(), inet::IPv6NeighbourDiscovery::initiateDAD(), inet::IPv6NeighbourDiscovery::processARTimeout(), and inet::IPv6NeighbourDiscovery::processDADTimeout().

    {
        return IPv6Address(*this).setPrefix(SOLICITED_NODE_PREFIX, 104);
    };

IPv6Address inet::IPv6Address::formSubnetRouterAnycastAddress ( int  prefixLength ) const

inline

Returns the subnet-router anycast address for this address by setting its suffix (the last 128-prefixLength bits) to all-zeroes.

See section 2.6.1 of RFC 3513.

    {
        return IPv6Address(*this).setSuffix(UNSPECIFIED_ADDRESS, prefixLength);
    }

int inet::IPv6Address::getMulticastScope

(

)

const

Get the 4-bit scope field of an IPv6 multicast address.

{
    if ((d[0] & MULTICAST_MASK) != MULTICAST_PREFIX)
        throw cRuntimeError("IPv6Address::getMulticastScope(): %s is not a multicast address", str().c_str());
    return (d[0] >> 16) & 0x0F;
}

IPv6Address inet::IPv6Address::getPrefix

(

int

prefixLength

)

const

Get the IPv6 first prefixLength bits of the address, with the rest set to zero.

{
    // First we construct a mask.
    uint32 mask[4];
    constructMask(prefixLength, mask);

    // Now we mask each IPv6 address segment and create a new IPv6 Address!
    return IPv6Address(d[0] & mask[0], d[1] & mask[1], d[2] & mask[2], d[3] & mask[3]);
}

IPv6Address::Scope inet::IPv6Address::getScope

(

)

const

Get the IPv6 address scope.

Referenced by inet::IPv6InterfaceData::addrLess(), inet::sctp::SCTPAssociation::getAddressLevel(), inet::L3AddressResolver::getIPv6AddressFrom(), inet::IPv6NeighbourDiscovery::processRAPrefixInfoForAddrAutoConf(), and inet::xMIPv6::validateType2RH().

{
    //Mask the given IPv6 address with the different mask types
    //to get only the IPv6 address scope. Compare the masked
    //address with the different prefixes.

    if ((d[0] & LINK_LOCAL_MASK) == LINK_LOCAL_PREFIX) {
        return LINK;
    }
    else if ((d[0] & SITE_LOCAL_MASK) == SITE_LOCAL_PREFIX) {
        return SITE;
    }
    else if ((d[0] & MULTICAST_MASK) == MULTICAST_PREFIX) {
        return MULTICAST;
    }
    else if (d[0] == 0x00000000 && d[1] == 0x00000000 && d[2] == 0x00000000) {
        if (d[3] == 0x00000000) {
            return UNSPECIFIED;
        }
        else if (d[3] == 0x00000001) {
            return LOOPBACK;
        }
        else {
            return GLOBAL;    // actually an "IPv4-compatible IPv6 address"
        }
    }
    else {
        return GLOBAL;
    }
}

IPv6Address inet::IPv6Address::getSuffix

(

int

prefixLength

)

const

Get the last 128-prefixLength bits of the address, with the first bits set to zero.

{
    // First we construct a mask.
    uint32 mask[4];
    constructMask(prefixLength, mask);

    // Now we mask each IPv6 address segment, inverse it
    // and create a new IPv6 Address!
    return IPv6Address(d[0] & ~mask[0], d[1] & ~mask[1], d[2] & ~mask[2], d[3] & ~mask[3]);
}

bool inet::IPv6Address::isGlobal ( ) const

inline

Utility function based on getScope()

Referenced by inet::FlatNetworkConfigurator6::addOwnAdvPrefixRoutes(), inet::IPv6InterfaceData::addrLess(), inet::FlatNetworkConfigurator6::addStaticRoutes(), inet::IPv6InterfaceData::assignAddress(), inet::PingApp::getAllAddresses(), inet::IPv6RoutingTable::initialize(), and inet::xMIPv6::validateBUMessage().

{ return getScope() == GLOBAL; }

bool inet::IPv6Address::isLinkLocal ( ) const

inline

Utility function based on getScope()

Referenced by inet::L3Address::isLinkLocal(), inet::IPv6NeighbourDiscovery::processRAPrefixInfo(), inet::IPv6NeighbourDiscovery::processRAPrefixInfoForAddrAutoConf(), inet::IPv6::routePacket(), and inet::IPv6NeighbourDiscovery::validateRAPacket().

{ return getScope() == LINK; }

bool inet::IPv6Address::isLoopback ( ) const

inline

Utility function based on getScope()

Referenced by inet::IPv6::routePacket().

{ return getScope() == LOOPBACK; }

bool inet::IPv6Address::isMulticast ( ) const

inline

Utility function based on getScope()

Referenced by inet::IPv6InterfaceData::addMulticastListener(), inet::IPv6::datagramLocalOut(), inet::IPv6::handleMessageFromHL(), inet::L3Address::isMulticast(), inet::IPv6InterfaceData::joinMulticastGroup(), inet::IPv6InterfaceData::leaveMulticastGroup(), inet::IPv6::preroutingFinish(), inet::ICMPv6::processEchoRequest(), inet::UDP::processUDPPacket(), inet::ICMPv6::validateDatagramPromptingError(), inet::IPv6NeighbourDiscovery::validateNAPacket(), and inet::IPv6NeighbourDiscovery::validateNSPacket().

{ return getScope() == MULTICAST; }

bool inet::IPv6Address::isSiteLocal ( ) const

inline

Utility function based on getScope()

{ return getScope() == SITE; }

bool inet::IPv6Address::isSolicitedNodeMulticastAddress ( ) const

inline

Referenced by inet::IPv6::fragmentAndSend().

    {
        return matches(SOLICITED_NODE_PREFIX, 104);
    }

bool inet::IPv6Address::isUnicast ( ) const

inline

Utility function based on getScope()

Referenced by inet::IPv6Tunneling::createTunnel(), inet::L3Address::isUnicast(), inet::IPv6NeighbourDiscovery::processNSForTentativeAddress(), inet::xMIPv6::validateBUMessage(), and inet::xMIPv6::validateType2RH().

{ return getScope() != MULTICAST && getScope() != UNSPECIFIED; }

bool inet::IPv6Address::isUnspecified ( ) const

inline

Check if the IPv6 Address is undefined.

Referenced by inet::IPv6NeighbourDiscovery::assignLinkLocalAddress(), inet::FlatNetworkConfigurator6::configureAdvPrefixes(), inet::xMIPv6::createAndSendBRRMessage(), inet::xMIPv6::createAndSendBUMessage(), inet::IPv6NeighbourDiscovery::createAndSendNSPacket(), inet::IPv6NeighbourDiscovery::determineNextHop(), inet::IPv6::determineOutputInterface(), inet::IPv6::encapsulate(), inet::IPv6Tunneling::encapsulateDatagram(), inet::IPv6::fragmentAndSend(), inet::PingApp::getAllAddresses(), inet::IPv6RoutingTable::getInterfaceByAddress(), inet::L3AddressResolver::getInterfaceIPv6Address(), inet::IPv6::handleMessageFromHL(), inet::L3Address::isUnspecified(), inet::IPv6NeighbourDiscovery::makeTentativeAddressPermanent(), inet::IPv6NeighbourDiscovery::processIPv6Datagram(), inet::IPv6NeighbourDiscovery::processNSForNonTentativeAddress(), inet::IPv6NeighbourDiscovery::processNSForTentativeAddress(), inet::IPv6NeighbourDiscovery::processRAPrefixInfo(), inet::IPv6NeighbourDiscovery::processRAPrefixInfoForAddrAutoConf(), inet::IPv6::resolveMACAddressAndSendPacket(), inet::ICMPv6::sendErrorMessage(), inet::IPv6NeighbourDiscovery::sendSolicitedNA(), inet::xMIPv6::sendTestInit(), str(), inet::IPv6NeighbourDiscovery::validateNSPacket(), and inet::IPv6NeighbourDiscovery::validateRSPacket().

{ return (d[0] | d[1] | d[2] | d[3]) == 0; }

bool inet::IPv6Address::matches	(	const IPv6Address &	prefix,
		int	prefixLength
	)		const

Returns true if the address matches the given prefix.

Referenced by inet::IPv6NeighbourDiscovery::createAndSendNSPacket(), inet::IPv6RoutingTable::doLongestPrefixMatch(), inet::IPv6RoutingTable::isLocalAddress(), inet::InterfaceTable::isNeighborAddress(), inet::IPv6RoutingTable::isOnLinkAddress(), inet::IPv6RoutingTable::isPrefixPresent(), inet::MultiFieldClassifier::Filter::matches(), inet::L3Address::matches(), inet::IPv6NeighbourDiscovery::processRAPrefixInfo(), inet::IPv6NeighbourDiscovery::processRAPrefixInfoForAddrAutoConf(), and inet::IPv6NeighbourDiscovery::validateNSPacket().

{
    // first we construct a mask.
    uint32 mask[4];
    constructMask(prefixLength, mask);

    // xor the bits of the 2 addresses, and the result should be zero wherever
    // the mask has 1 bits
    return (((d[0] ^ prefix.d[0]) & mask[0]) | ((d[1] ^ prefix.d[1]) & mask[1])
            | ((d[2] ^ prefix.d[2]) & mask[2]) | ((d[3] ^ prefix.d[3]) & mask[3])) == 0;
}

bool inet::IPv6Address::operator!= ( const IPv6Address &  addr ) const

inline

{ return !operator==(addr); }

bool inet::IPv6Address::operator< ( const IPv6Address &  addr ) const

inline

{ return compare(addr) < 0; }

bool inet::IPv6Address::operator== ( const IPv6Address &  addr ) const

inline

    {
        return d[3] == addr.d[3] && d[2] == addr.d[2] && d[1] == addr.d[1] && d[0] == addr.d[0];    // d[3] differs most often, compare that first
    }

bool inet::IPv6Address::operator> ( const IPv6Address &  addr ) const

inline

{ return compare(addr) > 0; }

const char * inet::IPv6Address::scopeName ( Scope  s )

static

Return the string representation of the given scope.

Referenced by inet::IPv6InterfaceData::info().

{
    switch (scope) {
        case UNSPECIFIED:
            return "unspec";

        case LOOPBACK:
            return "loopback";

        case MULTICAST:
            return "mcast";

        case LINK:
            return "link";

        case SITE:
            return "site";

        case GLOBAL:
            return "global";

        default:
            return "???";
    }
}

void inet::IPv6Address::set

(

const char *

addr

)

Sets the IPv6 address.

Given a string.

Referenced by inet::IPv6RoutingTable::configureTunnelFromXML(), and inet::serializer::IPv6Serializer::deserialize().

{
    if (!tryParse(addr))
        throw cRuntimeError("IPv6Address: cannot interpret address string `%s'", addr);
}

void inet::IPv6Address::set ( uint32  d0, uint32  d1, uint32  d2, uint32  d3  )

inline

Sets the IPv6 address from four 32-bit integers.

The most significant word should be passed in the first argument.

    {
        d[0] = d0;
        d[1] = d1;
        d[2] = d2;
        d[3] = d3;
    }

const IPv6Address & inet::IPv6Address::setPrefix	(	const IPv6Address &	fromAddr,
		int	prefixLength
	)

Overwrites the first prefixLength bits of the address with the bits from the address passed as argument.

Return value is the object itself.

Referenced by inet::IPv6InterfaceData::autoConfRouterGlobalScopeAddress(), formSolicitedNodeMulticastAddress(), inet::IPv6NeighbourDiscovery::processRAPacket(), inet::IPv6NeighbourDiscovery::processRAPrefixInfo(), and inet::IPv6NeighbourDiscovery::processRAPrefixInfoForAddrAutoConf().

{
    // first we construct a mask.
    uint32 mask[4];
    constructMask(prefixLength, mask);

    // combine the addresses
    d[0] = (d[0] & ~mask[0]) | (fromAddr.d[0] & mask[0]);
    d[1] = (d[1] & ~mask[1]) | (fromAddr.d[1] & mask[1]);
    d[2] = (d[2] & ~mask[2]) | (fromAddr.d[2] & mask[2]);
    d[3] = (d[3] & ~mask[3]) | (fromAddr.d[3] & mask[3]);
    return *this;
}

const IPv6Address & inet::IPv6Address::setSuffix	(	const IPv6Address &	fromAddr,
		int	prefixLength
	)

Overwrites the last 128-prefixLength bits of the address with the bits from address passed as argument.

Return value is the object itself.

Referenced by formLinkLocalAddress(), and formSubnetRouterAnycastAddress().

{
    // first we construct a mask.
    uint32 mask[4];
    constructMask(prefixLength, mask);

    // combine the addresses
    d[0] = (d[0] & mask[0]) | (fromAddr.d[0] & ~mask[0]);
    d[1] = (d[1] & mask[1]) | (fromAddr.d[1] & ~mask[1]);
    d[2] = (d[2] & mask[2]) | (fromAddr.d[2] & ~mask[2]);
    d[3] = (d[3] & mask[3]) | (fromAddr.d[3] & ~mask[3]);
    return *this;
}

std::string inet::IPv6Address::str

(

)

const

Returns the textual representation of the address in the standard notation.

Referenced by inet::IPv6InterfaceData::addMulticastListener(), inet::IPv6RoutingTable::doLongestPrefixMatch(), inet::PacketDump::dumpIPv6(), inet::IPv6::encapsulate(), inet::IPv6RoutingTable::getInterfaceByAddress(), getMulticastScope(), inet::IPv6RoutingTable::isLocalAddress(), inet::IPv6InterfaceData::joinMulticastGroup(), inet::IPv6InterfaceData::leaveMulticastGroup(), inet::IPv6RoutingTable::lookupDestCache(), inet::operator<<(), inet::IPv6NeighbourDiscovery::reachabilityConfirmed(), inet::IPv6NeighbourDiscovery::resolveNeighbour(), inet::L3Address::str(), and inet::InterfaceTable::updateLinkDisplayString().

{
    if (isUnspecified())
        return std::string("<unspec>");

    // convert to 16-bit grops
    uint16_t groups[8] = {
        uint16_t(d[0] >> 16), uint16_t(d[0] & 0xffff), uint16_t(d[1] >> 16), uint16_t(d[1] & 0xffff),
        uint16_t(d[2] >> 16), uint16_t(d[2] & 0xffff), uint16_t(d[3] >> 16), uint16_t(d[3] & 0xffff)
    };

    // find longest sequence of zeros in groups[]
    int start, end;
    findGap(groups, start, end);
    if (start == 0 && end == 8)
        return "::0"; // the unspecified address is a special case

    // print groups, replacing gap with "::"
    std::stringstream os;
    os << std::hex;
    for (int i = 0; i < start; i++)
        os << (i == 0 ? "" : ":") << groups[i];
    if (start != end)
        os << "::";
    for (int j = end; j < 8; j++)
        os << (j == end ? "" : ":") << groups[j];
    return os.str();
}

bool inet::IPv6Address::tryParse

(

const char *

addr

)

Tries parsing an IPv6 address string into the object.

Returns true if the string contains a well-formed IPv6 address, and false otherwise. All RFC 3513 notations are accepted (e.g. FEDC:BA98:7654:3210:FEDC:BA98:7654:3210, FF01::101, ::1), plus also "<unspec>" as a synonym for the unspecified address (all-zeroes).

Referenced by set(), and inet::L3Address::tryParse().

{
    if (!addr)
        return false;
    if (!doTryParse(addr))
        return false;
    if (*addr != 0)
        return false; // illegal trailing character
    return true;
}

bool inet::IPv6Address::tryParseAddrWithPrefix	(	const char *	addr,
		int &	prefixLen
	)

Expects a string in the "<address>/<prefixlength>" syntax, parses the address into the object (see tryParse(), and returns the prefix length (a 0..128 integer) in the second argument.

The return value is true if the operation was successful, and false if it was not (e.g. no slash in the input string, invalid address syntax, prefix length is out of range, etc.).

Referenced by inet::IPv6RoutingTable::configureInterfaceFromXML().

{
    if (!addr)
        return false;
    if (!doTryParse(addr))
        return false;
    if (*addr != '/')
        return false; // no '/' after address
    addr++;

    // parse prefix
    char *e;
    prefixLen = strtoul(addr, &e, 10);
    if (addr == e)
        return false; // no number after '/'
    if (*e != 0)
        return false; // garbage after number
    if (prefixLen < 0 || prefixLen > 128)
        return false; // wrong len value
    return true;
}

uint32* inet::IPv6Address::words ( )

inline

Returns a pointer to the internal binary representation of the address: four 32-bit words, most significant word first.

Referenced by inet::serializer::SCTPSerializer::deserialize(), inet::doPacking(), inet::doUnpacking(), inet::serializer::IPv6Serializer::serialize(), inet::L3Address::set(), and inet::serializer::Buffer::writeIPv6Address().

{ return d; }

const uint32* inet::IPv6Address::words ( ) const

inline

Returns a pointer to the internal binary representation of the address: four 32-bit words, most significant word first.

{ return d; }

Member Data Documentation

const IPv6Address inet::IPv6Address::ALL_NODES_1

static

All-nodes multicast address, scope 1 (interface-local)

Referenced by inet::IPv6AddressType::getBroadcastAddress(), inet::IPv6InterfaceData::HostMulticastData::info(), and inet::IPv6RoutingTable::isLocalAddress().

const IPv6Address inet::IPv6Address::ALL_NODES_2

static

All-nodes multicast address, scope 2 (link-local)

Referenced by inet::IPv6RoutingTable::configureInterfaceForIPv6(), inet::IPv6RoutingTable::isLocalAddress(), inet::IPv6NeighbourDiscovery::sendSolicitedNA(), and inet::IPv6NeighbourDiscovery::sendUnsolicitedNA().

const IPv6Address inet::IPv6Address::ALL_ROUTERS_1

static

All-routers multicast address, scope 1 (interface-local)

Referenced by inet::IPv6RoutingTable::isLocalAddress().

const IPv6Address inet::IPv6Address::ALL_ROUTERS_2

static

All-routers multicast address, scope 2 (link-local)

Referenced by inet::IPv6RoutingTable::configureInterfaceForIPv6(), inet::IPv6NeighbourDiscovery::createAndSendRSPacket(), and inet::IPv6RoutingTable::isLocalAddress().

const IPv6Address inet::IPv6Address::ALL_ROUTERS_5

static

All-routers multicast address, scope 5 (site-local)

Referenced by inet::IPv6RoutingTable::isLocalAddress().

uint32 inet::IPv6Address::d[4]

private

Referenced by compare(), constructMask(), doTryParse(), getMulticastScope(), getPrefix(), getScope(), getSuffix(), matches(), operator==(), setPrefix(), setSuffix(), and str().

const IPv6Address inet::IPv6Address::LINKLOCAL_PREFIX

static

The link-local prefix (fe80::)

Referenced by inet::IPv6RoutingTable::configureInterfaceForIPv6(), and formLinkLocalAddress().

const IPv6Address inet::IPv6Address::LL_MANET_ROUTERS

static

Link-local MANET routers multicast address.

Referenced by inet::IPv6AddressType::getLinkLocalManetRoutersMulticastAddress().

const IPv6Address inet::IPv6Address::LOOPBACK_ADDRESS

static

The loopback address.

Referenced by inet::ICMPv6::sendErrorMessage().

const IPv6Address inet::IPv6Address::SOLICITED_NODE_PREFIX

static

The solicited-node multicast address prefix (prefix length = 104)

Referenced by inet::IPv6RoutingTable::isLocalAddress(), and inet::IPv6NeighbourDiscovery::validateNSPacket().

const IPv6Address inet::IPv6Address::UNSPECIFIED_ADDRESS

static

The unspecified address.

Referenced by inet::IPv6InterfaceData::choosePreferredAddress(), inet::IPv6RoutingTable::configureInterfaceForIPv6(), inet::IPv6NeighbourDiscovery::createAndSendRSPacket(), inet::IPv6Tunneling::createTunnel(), inet::IPv6::datagramLocalInHook(), inet::IPv6::endService(), inet::IPv6InterfaceData::getGlobalAddress(), inet::IPv6RoutingTable::getHomeAddress(), inet::IPv6AddressType::getLinkLocalAddress(), inet::IPv6InterfaceData::getLinkLocalAddress(), inet::IPv6AddressType::getUnspecifiedAddress(), inet::IPv6::handleMessageFromHL(), inet::IPv6NeighbourDiscovery::initiateDAD(), inet::IPv6RoutingTable::lookupDestCache(), inet::IPv6Tunneling::numInitStages(), inet::xMIPv6::numInitStages(), inet::IPv6NeighbourDiscovery::processDADTimeout(), inet::IPv6NeighbourDiscovery::selectDefaultRouter(), and inet::IPv6InterfaceData::updateHomeNetworkInfo().

---

The documentation for this class was generated from the following files:

• IPv6Address.h
• IPv6Address.cc