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...

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

Private Attributes
uint32_t	d [4]

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...
static const Ipv6Address	ALL_OSPF_ROUTERS_MCAST
	OSPF multicast address for listening. More...
static const Ipv6Address	ALL_OSPF_DESIGNATED_ROUTERS_MCAST
	OSPF designated routers. More...
	Ipv6Address ()
	Constructor. More...
	Ipv6Address (uint64_t hi, uint64_t lo)
	Constructs an Ipv6 address from two 64-bit integers. More...
	Ipv6Address (uint32_t segment0, uint32_t segment1, uint32_t segment2, uint32_t 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_t d0, uint32_t d1, uint32_t d2, uint32_t d3)
	Sets the Ipv6 address from four 32-bit integers. More...
uint32_t *	words ()
	Returns a pointer to the internal binary representation of the address: four 32-bit words, most significant word first. More...
const uint32_t *	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...
MacAddress	mapToMulticastMacAddress () const
static const char *	scopeName (Scope s)
	Return the string representation of the given scope. More...
static void	constructMask (int prefixLength, uint32_t *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...

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

Scope

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

Ipv6Address() [1/4]

inet::Ipv6Address::Ipv6Address ( )

inline

Constructor.

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

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

Referenced by getPrefix(), and getSuffix().

Ipv6Address() [2/4]

inet::Ipv6Address::Ipv6Address ( uint64_t  hi, uint64_t  lo  )

inline

Constructs an Ipv6 address from two 64-bit integers.

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

Ipv6Address() [3/4]

inet::Ipv6Address::Ipv6Address ( uint32_t  segment0, uint32_t  segment1, uint32_t  segment2, uint32_t  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;
    }

Ipv6Address() [4/4]

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

compare()

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;
    }

constructMask() [1/2]

Ipv6Address inet::Ipv6Address::constructMask ( int  prefixLength )

static

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

constructMask() [2/2]

void inet::Ipv6Address::constructMask ( int  prefixLength, uint32_t *  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.

{
    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;
    }
}

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

doTryParse()

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

protected

{
    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;
}

Referenced by tryParse(), and tryParseAddrWithPrefix().

formLinkLocalAddress()

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

static

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

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

Referenced by inet::Ipv6NeighbourDiscovery::assignLinkLocalAddress(), inet::Ipv6RoutingTable::assignRequiredNodeAddresses(), and inet::Ipv6FlatNetworkConfigurator::configureAdvPrefixes().

formSolicitedNodeMulticastAddress()

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.

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

Referenced by inet::Ipv6NeighbourDiscovery::initiateAddressResolution(), inet::Ipv6NeighbourDiscovery::initiateDad(), inet::Ipv6NeighbourDiscovery::processArTimeout(), and inet::Ipv6NeighbourDiscovery::processDadTimeout().

formSubnetRouterAnycastAddress()

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);
    }

getMulticastScope()

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;
}

getPrefix()

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_t 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]);
}

Referenced by inet::ospfv3::Ipv6AddressRange::containedByRange(), inet::ospfv3::Ipv6AddressRange::contains(), inet::ospfv3::Ipv6AddressRange::containsRange(), inet::ospfv3::Ospfv3Area::detailedInfo(), inet::eigrp::EigrpIpv6Pdm::enableInterface(), inet::ospfv3::Ospfv3Process::isInRoutingTable6(), inet::ospfv3::isSameNetwork(), inet::eigrp::EigrpDeviceConfigurator::loadEigrpInterfaces6Config(), inet::ospfv3::Ospfv3Area::originateIntraAreaPrefixLSA(), inet::ospfv3::Ospfv3Interface::originateLinkLSA(), inet::ospfv3::Ospfv3Area::originateNetIntraAreaPrefixLSA(), and inet::ospfv3::Ospfv3Process::parseConfig().

getScope()

Ipv6Address::Scope inet::Ipv6Address::getScope

(

)

const

Get the Ipv6 address scope.

{
    // 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;
    }
}

Referenced by inet::Ipv6InterfaceData::addrLess(), inet::eigrp::EigrpIpv6Pdm::checkNeighborshipRules(), inet::sctp::SctpAssociation::getAddressLevel(), inet::L3AddressResolver::getIpv6AddressFrom(), inet::eigrp::EigrpDeviceConfigurator::loadEigrpInterfaces6Config(), and inet::xMIPv6::validateType2RH().

getSuffix()

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_t 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]);
}

isGlobal()

bool inet::Ipv6Address::isGlobal ( ) const

inline

Utility function based on getScope()

{ return getScope() == GLOBAL; }

Referenced by inet::Ipv6InterfaceData::addrLess(), inet::Ipv6InterfaceData::assignAddress(), inet::Ipv6FlatNetworkConfigurator::configureAdvPrefixes(), inet::PingApp::getAllAddresses(), inet::Ipv6RoutingTable::initialize(), inet::ospfv3::Ospfv3Area::originateIntraAreaPrefixLSA(), inet::ospfv3::Ospfv3Interface::originateLinkLSA(), inet::ospfv3::Ospfv3Area::originateNetIntraAreaPrefixLSA(), and inet::xMIPv6::validateBUMessage().

isLinkLocal()

bool inet::Ipv6Address::isLinkLocal ( ) const

inline

Utility function based on getScope()

{ return getScope() == LINK; }

Referenced by inet::L3Address::isLinkLocal(), inet::Ipv6NeighbourDiscovery::processRaPrefixInfo(), inet::Ipv6NeighbourDiscovery::processRaPrefixInfoForAddrAutoConf(), and inet::Ipv6NeighbourDiscovery::validateRaPacket().

isLoopback()

bool inet::Ipv6Address::isLoopback ( ) const

inline

Utility function based on getScope()

{ return getScope() == LOOPBACK; }

isMulticast()

bool inet::Ipv6Address::isMulticast ( ) const

inline

Utility function based on getScope()

{ return getScope() == MULTICAST; }

Referenced by inet::Ipv6InterfaceData::addMulticastListener(), inet::L3Address::isMulticast(), inet::Ipv6InterfaceData::joinMulticastGroup(), inet::Ipv6InterfaceData::leaveMulticastGroup(), mapToMulticastMacAddress(), and inet::Ipv6NeighbourDiscovery::validateNaPacket().

isSiteLocal()

bool inet::Ipv6Address::isSiteLocal ( ) const

inline

Utility function based on getScope()

{ return getScope() == SITE; }

isSolicitedNodeMulticastAddress()

bool inet::Ipv6Address::isSolicitedNodeMulticastAddress ( ) const

inline

    {
        return matches(SOLICITED_NODE_PREFIX, 104);
    }

isUnicast()

bool inet::Ipv6Address::isUnicast ( ) const

inline

Utility function based on getScope()

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

Referenced by inet::Ipv6Tunneling::createTunnel(), inet::L3Address::isUnicast(), inet::Ipv6NeighbourDiscovery::processNsForTentativeAddress(), inet::xMIPv6::validateBUMessage(), and inet::xMIPv6::validateType2RH().

isUnspecified()

bool inet::Ipv6Address::isUnspecified ( ) const

inline

Check if the Ipv6 Address is undefined.

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

Referenced by inet::Ipv6NeighbourDiscovery::assignLinkLocalAddress(), inet::xMIPv6::createAndSendBRRMessage(), inet::xMIPv6::createAndSendBUMessage(), inet::Ipv6NeighbourDiscovery::createAndSendNsPacket(), inet::Ipv6NeighbourDiscovery::createAndSendRsPacket(), inet::Ipv6NeighbourDiscovery::determineNextHop(), inet::Ipv6::determineOutputInterface(), inet::Ipv6Tunneling::encapsulateDatagram(), inet::Ipv6::fragmentAndSend(), inet::Ipv6::fragmentPostRouting(), inet::PingApp::getAllAddresses(), inet::L3AddressResolver::getInterfaceIpv6Address(), inet::eigrp::EigrpIpv6Pdm::getNextHopAddr(), inet::Ipv6Route::getSourceTypeAbbreviation(), inet::Ipv6::handleMessageFromHL(), inet::GlobalArp::initialize(), inet::eigrp::EigrpNetworkTable< inet::Ipv4Address >::isInterfaceIncluded(), inet::L3Address::isUnspecified(), inet::Ipv6NeighbourDiscovery::processIpv6Datagram(), inet::Ipv6NeighbourDiscovery::processNsForNonTentativeAddress(), inet::Ipv6NeighbourDiscovery::processNsForTentativeAddress(), inet::Ipv6NeighbourDiscovery::processRaPrefixInfoForAddrAutoConf(), inet::Ipv6::resolveMACAddressAndSendPacket(), inet::Ipv6NeighbourDiscovery::sendSolicitedNa(), inet::xMIPv6::sendTestInit(), str(), inet::Ipv6NeighbourDiscovery::validateNsPacket(), and inet::Ipv6NeighbourDiscovery::validateRsPacket().

mapToMulticastMacAddress()

MacAddress inet::Ipv6Address::mapToMulticastMacAddress

(

)

const

{
    ASSERT(isMulticast());
 
    MacAddress macAddress;
    macAddress.setAddressByte(0, 0x33);
    macAddress.setAddressByte(1, 0x33);
    macAddress.setAddressByte(2, (d[3] >> 24) & 0xFF);
    macAddress.setAddressByte(3, (d[3] >> 16) & 0xFF);
    macAddress.setAddressByte(4, (d[3] >> 8)  & 0xFF);
    macAddress.setAddressByte(5, (d[3] >> 0)  & 0xFF);
    return macAddress;
}

Referenced by inet::L3Address::mapToMulticastMacAddress().

matches()

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

Returns true if the address matches the given prefix.

{
    // first we construct a mask.
    uint32_t 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;
}

Referenced by inet::Ipv6NeighbourDiscovery::createAndSendNsPacket(), inet::Ipv6RoutingTable::doLongestPrefixMatch(), inet::Ipv6RoutingTable::isLocalAddress(), inet::InterfaceTable::isNeighborAddress(), inet::Ipv6RoutingTable::isPrefixPresent(), inet::L3Address::matches(), inet::Ipv6NeighbourDiscovery::processRaPrefixInfoForAddrAutoConf(), and inet::Ipv6NeighbourDiscovery::validateNsPacket().

operator!=()

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

inline

{ return !operator==(addr); }

operator<()

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

inline

{ return compare(addr) < 0; }

operator==()

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
    }

operator>()

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

inline

{ return compare(addr) > 0; }

scopeName()

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

static

Return the string representation of the given scope.

{
    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 "???";
    }
}

Referenced by inet::Ipv6InterfaceData::str().

set() [1/2]

void inet::Ipv6Address::set

(

const char *

addr

)

Sets the Ipv6 address.

Given a string.

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

Referenced by inet::Ipv6RoutingTable::configureTunnelFromXml(), and inet::eigrp::EigrpIpv6Pdm::getDestIpAddress().

set() [2/2]

void inet::Ipv6Address::set ( uint32_t  d0, uint32_t  d1, uint32_t  d2, uint32_t  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;
    }

setPrefix()

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.

{
    // first we construct a mask.
    uint32_t 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;
}

Referenced by formSolicitedNodeMulticastAddress(), and inet::Ipv6NeighbourDiscovery::processRaPrefixInfoForAddrAutoConf().

setSuffix()

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.

{
    // first we construct a mask.
    uint32_t 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;
}

Referenced by formLinkLocalAddress(), and formSubnetRouterAnycastAddress().

str()

std::string inet::Ipv6Address::str

(

)

const

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

{
    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();
}

Referenced by inet::Ipv6InterfaceData::addMulticastListener(), inet::PacketFilter::DynamicExpressionResolver::callMethod(), inet::ospfv3::Ospfv3Area::detailedInfo(), inet::Ipv6RoutingTable::doLongestPrefixMatch(), inet::Ipv6RoutingTable::getInterfaceByAddress(), getMulticastScope(), inet::Ipv6::handleMessageFromHL(), inet::Ipv6RoutingTable::isLocalAddress(), inet::Ipv6InterfaceData::joinMulticastGroup(), inet::Ipv6InterfaceData::leaveMulticastGroup(), inet::Ipv6RoutingTable::lookupDestCache(), inet::Ipv6NeighbourDiscovery::reachabilityConfirmed(), inet::Ipv6NeighbourDiscovery::resolveNeighbour(), inet::L3Address::str(), inet::ospfv3::Ipv6AddressRange::str(), and inet::InterfaceTable::updateLinkDisplayString().

tryParse()

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).

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

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

tryParseAddrWithPrefix()

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.).

{
    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;
}

Referenced by inet::Ipv6RoutingTable::configureInterfaceFromXml(), inet::eigrp::EigrpDeviceConfigurator::loadEigrpInterfaces6Config(), and inet::ospfv3::Ospfv3Process::parseConfig().

words() [1/2]

uint32_t* inet::Ipv6Address::words ( )

inline

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

{ return d; }

Referenced by inet::doPacking(), inet::doUnpacking(), inet::eigrp::EigrpIpv6Pdm::getDestIpAddress(), inet::getNetmaskLength(), inet::getPrefix(), inet::maskedAddrAreEqual(), inet::sctp::SctpHeaderSerializer::serialize(), inet::L3Address::set(), and inet::MemoryOutputStream::writeIpv6Address().

words() [2/2]

const uint32_t* 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

ALL_NODES_1

const Ipv6Address inet::Ipv6Address::ALL_NODES_1

static

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

Referenced by inet::Ipv6AddressType::getBroadcastAddress(), inet::Ipv6RoutingTable::isLocalAddress(), and inet::Ipv6InterfaceData::HostMulticastData::str().

ALL_NODES_2

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().

ALL_OSPF_DESIGNATED_ROUTERS_MCAST

const Ipv6Address inet::Ipv6Address::ALL_OSPF_DESIGNATED_ROUTERS_MCAST

static

OSPF designated routers.

Referenced by inet::ospfv3::Ospfv3Interface::acknowledgeLSA(), inet::ospfv3::Ospfv3Interface::addDelayedAcknowledgement(), inet::ospfv3::Ospfv3InterfaceState::changeState(), inet::ospfv3::Ospfv3Interface::floodLSA(), inet::Ipv6RoutingTable::isLocalAddress(), inet::ospfv3::Ospfv3Interface::processLSR(), inet::ospfv3::Ospfv3Interface::processLSU(), inet::ospfv3::Ospfv3Instance::processPacket(), and inet::ospfv3::Ospfv3Interface::sendDelayedAcknowledgements().

ALL_OSPF_ROUTERS_MCAST

const Ipv6Address inet::Ipv6Address::ALL_OSPF_ROUTERS_MCAST

static

OSPF multicast address for listening.

Referenced by inet::ospfv3::Ospfv3Interface::acknowledgeLSA(), inet::ospfv3::Ospfv3Interface::addDelayedAcknowledgement(), inet::ospfv3::Ospfv3Interface::floodLSA(), inet::Ipv6RoutingTable::isLocalAddress(), inet::ospfv3::Ospfv3Splitter::parseConfig(), inet::ospfv3::Ospfv3InterfaceStateDr::processEvent(), inet::ospfv3::Ospfv3InterfaceStateDrOther::processEvent(), inet::ospfv3::Ospfv3InterfaceStateWaiting::processEvent(), inet::ospfv3::Ospfv3InterfaceStatePointToPoint::processEvent(), inet::ospfv3::Ospfv3InterfaceStateBackup::processEvent(), inet::ospfv3::Ospfv3Interface::processLSR(), inet::ospfv3::Ospfv3Interface::processLSU(), inet::ospfv3::Ospfv3Neighbor::sendDDPacket(), inet::ospfv3::Ospfv3Interface::sendDelayedAcknowledgements(), and inet::ospfv3::Ospfv3Neighbor::sendLinkStateRequestPacket().

ALL_ROUTERS_1

const Ipv6Address inet::Ipv6Address::ALL_ROUTERS_1

static

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

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

ALL_ROUTERS_2

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().

ALL_ROUTERS_5

const Ipv6Address inet::Ipv6Address::ALL_ROUTERS_5

static

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

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

d

uint32_t inet::Ipv6Address::d[4]

private

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

LINKLOCAL_PREFIX

const Ipv6Address inet::Ipv6Address::LINKLOCAL_PREFIX

static

The link-local prefix (fe80::)

Referenced by inet::Ipv6RoutingTable::configureInterfaceForIpv6(), formLinkLocalAddress(), and inet::eigrp::EigrpIpv6Pdm::processIfaceStateChange().

LL_MANET_ROUTERS

const Ipv6Address inet::Ipv6Address::LL_MANET_ROUTERS

static

Link-local MANET routers multicast address.

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

LOOPBACK_ADDRESS

const Ipv6Address inet::Ipv6Address::LOOPBACK_ADDRESS

static

The loopback address.

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

SOLICITED_NODE_PREFIX

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().

UNSPECIFIED_ADDRESS

const Ipv6Address inet::Ipv6Address::UNSPECIFIED_ADDRESS

static

The unspecified address.

Referenced by inet::ospfv3::Ospfv3InterfaceState::calculateDesignatedRouter(), inet::ospfv3::Ospfv3Area::calculateNextHops(), inet::ospfv3::Ospfv3Area::calculateShortestPathTree(), inet::Ipv6InterfaceData::choosePreferredAddress(), inet::Ipv6RoutingTable::configureInterfaceForIpv6(), inet::Ipv6NeighbourDiscovery::createAndSendRsPacket(), inet::eigrp::EigrpIpv6Pdm::createRouteTlv(), inet::Ipv6Tunneling::createTunnel(), inet::ospfv3::Ospfv3Area::detailedInfo(), inet::Ipv6InterfaceData::getGlblAddress(), inet::GlobalArp::getL3AddressFor(), inet::Ipv6AddressType::getLinkLocalAddress(), inet::Ipv6InterfaceData::getLinkLocalAddress(), inet::Ipv6AddressType::getUnspecifiedAddress(), inet::Ipv6::handleMessage(), inet::Ipv6::handleMessageFromHL(), inet::Ipv6NeighbourDiscovery::initiateDad(), inet::Ipv6RoutingTable::lookupDestCache(), inet::ospfv3::Ospfv3Neighbor::Ospfv3Neighbor(), inet::Ipv6NeighbourDiscovery::processDadTimeout(), inet::eigrp::EigrpIpv6Pdm::processIfaceStateChange(), inet::ospfv3::Ospfv3Process::rebuildRoutingTable(), and inet::Ipv6NeighbourDiscovery::selectDefaultRouter().

---

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

• Ipv6Address.h
• Ipv6Address.cc