IPvXAddress Class Reference

#include <IPvXAddress.h>

List of all members.


Detailed Description

Stores an IPv4 or an IPv6 address. This class should be used everywhere in transport layer and up, to guarantee IPv4/IPv6 transparence.

Storage is efficient: an object occupies size of an IPv6 address (128bits=16 bytes) plus a bool.

Public Member Functions

 IPvXAddress ()
 IPvXAddress (const IPAddress &addr)
 IPvXAddress (const IPv6Address &addr)
 IPvXAddress (const char *addr)
 IPvXAddress (const IPvXAddress &addr)
 ~IPvXAddress ()
bool isIPv6 () const
IPAddress get4 () const
IPv6Address get6 () const
void set (const IPAddress &addr)
void set (const IPv6Address &addr)
void set (const IPvXAddress &addr)
void set (const char *addr)
IPvXAddressoperator= (const IPAddress &addr)
IPvXAddressoperator= (const IPv6Address &addr)
IPvXAddressoperator= (const IPvXAddress &addr)
bool tryParse (const char *addr)
std::string str () const
bool isUnspecified () const
bool equals (const IPAddress &addr) const
bool equals (const IPv6Address &addr) const
bool equals (const IPvXAddress &addr) const
bool operator== (const IPAddress &addr) const
bool operator!= (const IPAddress &addr) const
bool operator== (const IPv6Address &addr) const
bool operator!= (const IPv6Address &addr) const
bool operator== (const IPvXAddress &addr) const
bool operator!= (const IPvXAddress &addr) const
bool operator< (const IPvXAddress &addr) const

Protected Attributes

uint32 d [4]
bool isv6


Constructor & Destructor Documentation

IPvXAddress::IPvXAddress (  )  [inline]

name Constructors, destructor Constructor for IPv4 addresses.

00047 {isv6 = false; d[0] = 0;}

IPvXAddress::IPvXAddress ( const IPAddress addr  )  [inline]

Constructor for IPv4 addresses.

00052 {set(addr);}

IPvXAddress::IPvXAddress ( const IPv6Address addr  )  [inline]

Constructor for IPv6 addresses.

00057 {set(addr);}

IPvXAddress::IPvXAddress ( const char *  addr  )  [inline]

Accepts string representations suuported by IPAddress (dotted decimal notation) and IPv6Address (hex string with colons). Throws an error if the format is not recognized.

00064 {set(addr);}

IPvXAddress::IPvXAddress ( const IPvXAddress addr  )  [inline]

Copy constructor.

00069 {set(addr);}

IPvXAddress::~IPvXAddress (  )  [inline]

Destructor

00074 {}


Member Function Documentation

bool IPvXAddress::isIPv6 (  )  const [inline]

IPAddress IPvXAddress::get4 (  )  const [inline]

IPv6Address IPvXAddress::get6 (  )  const [inline]

Get IPv6 address. Throws exception if this is an IPv4 address.

Referenced by doPacking(), SCTPAssociation::getLevel(), UDP::matchesSocket(), IPTrafGen::sendPacket(), PingApp::sendToICMP(), TCPSpoof::sendToIP(), TCPConnection::sendToIP(), and SCTPAssociation::sendToIP().

00096                              {
00097         if (!isv6)  {
00098             if (d[0]==0) // allow null address to be returned as IPv6
00099                 return IPv6Address();
00100             throw cRuntimeError("IPvXAddress: cannot return IPv4 address %s as IPv6", str().c_str());
00101         }
00102         return IPv6Address(d[0], d[1], d[2], d[3]);
00103     }

void IPvXAddress::set ( const IPAddress addr  )  [inline]

Set to an IPv4 address.

Referenced by doUnpacking(), and SCTP::findAssocForMessage().

00108                                      {
00109         isv6 = false;
00110         d[0] = addr.getInt();
00111     }

void IPvXAddress::set ( const IPv6Address addr  )  [inline]

Set to an IPv6 address.

00116                                        {
00117         if (addr.isUnspecified()) {
00118             // we always represent nulls as IPv4 null
00119             isv6 = false; d[0] = 0;
00120             return;
00121         }
00122         isv6 = true;
00123         uint32 *w = const_cast<IPv6Address&>(addr).words();
00124         d[0] = w[0]; d[1] = w[1]; d[2] = w[2]; d[3] = w[3];
00125     }

void IPvXAddress::set ( const IPvXAddress addr  )  [inline]

Assignment

00130                                       {
00131         isv6 = addr.isv6;
00132         d[0] = addr.d[0];
00133         if (isv6) {
00134             d[1] = addr.d[1]; d[2] = addr.d[2]; d[3] = addr.d[3];
00135          }
00136     }

void IPvXAddress::set ( const char *  addr  )  [inline]

Accepts string representations supported by IPAddress (dotted decimal notation) and IPv6Address (hex string with colons). Throws an error if the format is not recognized.

00143                                {
00144         if (!tryParse(addr))
00145             throw cRuntimeError("IPvXAddress: cannot interpret address string `%s'", addr);
00146     }

IPvXAddress& IPvXAddress::operator= ( const IPAddress addr  )  [inline]

Assignment

00151 {set(addr); return *this;}

IPvXAddress& IPvXAddress::operator= ( const IPv6Address addr  )  [inline]

Assignment

00156 {set(addr); return *this;}

IPvXAddress& IPvXAddress::operator= ( const IPvXAddress addr  )  [inline]

Assignment

00161 {set(addr); return *this;}

bool IPvXAddress::tryParse ( const char *  addr  ) 

Parses and assigns the given address and returns true if the string is recognized by IPAddress or IPv6Address, otherwise just returns false.

Referenced by IPAddressResolver::tryResolve().

00022 {
00023     // try as IPv4
00024     if (IPAddress::isWellFormed(addr))
00025     {
00026         set(IPAddress(addr));
00027         return true;
00028     }
00029 
00030     // try as IPv6
00031     IPv6Address ipv6;
00032     if (ipv6.tryParse(addr))
00033     {
00034         set(ipv6);
00035         return true;
00036     }
00037 
00038     // no luck
00039     return false;
00040 }

std::string IPvXAddress::str (  )  const [inline]

Returns the string representation of the address (e.g. "152.66.86.92")

Referenced by TCP::addSockPair(), operator<<(), and SCTPPathVariables::SCTPPathVariables().

00172 {return isv6 ? get6().str() : get4().str();}

bool IPvXAddress::isUnspecified (  )  const [inline]

bool IPvXAddress::equals ( const IPAddress addr  )  const [inline]

Returns true if the two addresses are equal

00187                                              {
00188         return !isv6 && d[0]==addr.getInt();
00189     }

bool IPvXAddress::equals ( const IPv6Address addr  )  const [inline]

Returns true if the two addresses are equal

00194                                                {
00195         uint32 *w = const_cast<IPv6Address&>(addr).words();
00196         return isv6 && d[0]==w[0] && d[1]==w[1] && d[2]==w[2] && d[3]==w[3];
00197     }

bool IPvXAddress::equals ( const IPvXAddress addr  )  const [inline]

Returns true if the two addresses are equal

00202                                                {
00203         return d[0]==addr.d[0] && (!isv6 || (d[1]==addr.d[1] && d[2]==addr.d[2] && d[3]==addr.d[3]));
00204     }

bool IPvXAddress::operator== ( const IPAddress addr  )  const [inline]

Returns equals(addr).

00209 {return equals(addr);}

bool IPvXAddress::operator!= ( const IPAddress addr  )  const [inline]

Returns !equals(addr).

00214 {return !equals(addr);}

bool IPvXAddress::operator== ( const IPv6Address addr  )  const [inline]

Returns equals(addr).

00219 {return equals(addr);}

bool IPvXAddress::operator!= ( const IPv6Address addr  )  const [inline]

Returns !equals(addr).

00224 {return !equals(addr);}

bool IPvXAddress::operator== ( const IPvXAddress addr  )  const [inline]

Returns equals(addr).

00229 {return equals(addr);}

bool IPvXAddress::operator!= ( const IPvXAddress addr  )  const [inline]

Returns !equals(addr).

00234 {return !equals(addr);}

bool IPvXAddress::operator< ( const IPvXAddress addr  )  const [inline]

Compares two addresses.

00239                                                   {
00240         if (isv6!=addr.isv6)
00241             return !isv6;
00242         else if (!isv6)
00243             return d[0]<addr.d[0];
00244         else
00245             return memcmp(&d, &addr.d, 16) < 0;  // this provides an ordering, though not surely the one one would expect
00246     }


Member Data Documentation

uint32 IPvXAddress::d[4] [protected]

Referenced by equals(), and operator<().

bool IPvXAddress::isv6 [protected]

Referenced by operator<().


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

Generated on Fri Mar 20 18:51:20 2009 for INET Framework for OMNeT++/OMNEST by  doxygen 1.5.5