IPAddress Class Reference

#include <IPAddress.h>

List of all members.

---

Detailed Description

IPv4 address.

Public Member Functions
IPAddress &	operator= (const IPAddress &obj)
bool	isUnspecified () const
bool	equals (const IPAddress &toCmp) const
IPAddress	doAnd (const IPAddress &ip) const
std::string	str () const
uint32	getInt () const
int	getDByte (int i) const
char	getIPClass () const
bool	isMulticast () const
bool	isLinkLocalMulticast () const
IPAddress	getNetwork () const
IPAddress	getNetworkMask () const
bool	isNetwork (const IPAddress &toCmp) const
bool	prefixMatches (const IPAddress &to_cmp, int numbits) const
int	numMatchingPrefixBits (const IPAddress &to_cmp) const
int	netmaskLength () const
bool	operator== (const IPAddress &addr1) const
bool	operator!= (const IPAddress &addr1) const
bool	operator< (const IPAddress &addr1) const
	IPAddress ()
	IPAddress (uint32 i)
	IPAddress (int i0, int i1, int i2, int i3)
	IPAddress (const char *t)
	IPAddress (const IPAddress &obj)
	~IPAddress ()
void	set (uint32 i)
void	set (int i0, int i1, int i2, int i3)
void	set (const char *t)
Static Public Member Functions
static bool	maskedAddrAreEqual (const IPAddress &addr1, const IPAddress &addr2, const IPAddress &netmask)
static bool	isWellFormed (const char *text)
Static Public Attributes
Predefined addresses
static const IPAddress	UNSPECIFIED_ADDRESS
	0.0.0.0
static const IPAddress	LOOPBACK_ADDRESS
	127.0.0.1
static const IPAddress	LOOPBACK_NETMASK
	255.0.0.0
static const IPAddress	ALLONES_ADDRESS
	255.255.255.255
static const IPAddress	ALL_HOSTS_MCAST
	224.0.0.1 All hosts on a subnet
static const IPAddress	ALL_ROUTERS_MCAST
	224.0.0.2 All routers on a subnet
static const IPAddress	ALL_DVMRP_ROUTERS_MCAST
	224.0.0.4 All DVMRP routers
static const IPAddress	ALL_OSPF_ROUTERS_MCAST
	224.0.0.5 All OSPF routers (DR Others)
static const IPAddress	ALL_OSPF_DESIGNATED_ROUTERS_MCAST
	224.0.0.6 All OSPF Designated Routers
Protected Member Functions
void	keepFirstBits (unsigned int n)
Static Protected Member Functions
static bool	parseIPAddress (const char *text, unsigned char tobytes[])
Protected Attributes
unsigned char	addr [4]

---

Constructor & Destructor Documentation

IPAddress::IPAddress (   )  [inline]

Default constructor, initializes to 0.0.0.0. {addr[0] = addr[1] = addr[2] = addr[3] = 0;}

IPAddress::IPAddress (  uint32  i  )

IP address as int { set(ip); }

IPAddress::IPAddress (  int  i0, int  i1, int  i2, int  i3 )

IP address bytes: "i0.i1.i2.i3" format { addr[0] = i0; addr[1] = i1; addr[2] = i2; addr[3] = i3; }

IPAddress::IPAddress (  const char *  t  )

IP address given as text: "192.66.86.1" { set(text); }

IPAddress::IPAddress (  const IPAddress &  obj  )

Copy constructor { operator=(obj); }

IPAddress::~IPAddress (   )  [inline]

{}

---

Member Function Documentation

IPAddress IPAddress::doAnd (  const IPAddress &  ip  )  const

Returns binary AND of the two addresses { return IPAddress(addr[0] & ip.addr[0], addr[1] & ip.addr[1], addr[2] & ip.addr[2], addr[3] & ip.addr[3]); }

bool IPAddress::equals (  const IPAddress &  toCmp  )  const

Returns true if the two addresses are equal { return (addr[0] == toCmp.addr[0]) && (addr[1] == toCmp.addr[1]) && (addr[2] == toCmp.addr[2]) && (addr[3] == toCmp.addr[3]); }

int IPAddress::getDByte (  int  i  )  const [inline]

Returns the corresponding part of the address specified by the index ("[0].[1].[2].[3]") {return addr[i];}

uint32 IPAddress::getInt (   )  const

Returns the address as an int. { return (addr[0] << 24) + (addr[1] << 16) + (addr[2] << 8) + (addr[3]); }

char IPAddress::getIPClass (   )  const

Returns the network class of the address: char 'A', 'B', 'C', 'D', 'E', or '?' (returned when the address begins with at least five 1 bits.) { if ((addr[0] & 0x80) == 0x00) // 0xxxx return 'A'; else if ((addr[0] & 0xC0) == 0x80) // 10xxx return 'B'; else if ((addr[0] & 0xE0) == 0xC0) // 110xx return 'C'; else if ((addr[0] & 0xF0) == 0xE0) // 1110x return 'D'; else if ((addr[0] & 0xF8) == 0xF0) // 11110 return 'E'; else return '?'; }

IPAddress IPAddress::getNetwork (   )  const

Returns an address with the network part of the address (the bits of the hosts part are to 0). For D and E class addresses, it returns a null address. { switch (getIPClass()) { case 'A': // Class A: network = 7 bits return IPAddress(addr[0], 0, 0, 0); case 'B': // Class B: network = 14 bits return IPAddress(addr[0], addr[1], 0, 0); case 'C': // Class C: network = 21 bits return IPAddress(addr[0], addr[1], addr[2], 0); default: // Class D or E return IPAddress(); } }

IPAddress IPAddress::getNetworkMask (   )  const

Returns an address with the network mask corresponding to the address class. For D and E class addresses, it returns a null address. { switch (getIPClass()) { case 'A': // Class A: network = 7 bits return IPAddress(255, 0, 0, 0); case 'B': // Class B: network = 14 bits return IPAddress(255, 255, 0, 0); case 'C': // Class C: network = 21 bits return IPAddress(255, 255, 255, 0); default: // Class D or E: return null address return IPAddress(); } }

bool IPAddress::isLinkLocalMulticast (   )  const [inline]

Returns true if this address is in the range 224.0.0.0 to 224.0.0.255. These addresses are reserved for local purposes meaning, that routers should not forward these datagrams since the applications that use these addresses do not need the datagrams to go further than one hop. {return addr[0]==224 && addr[1]==0 && addr[2]==0;}

bool IPAddress::isMulticast (   )  const [inline]

Returns true if this address is in the multicast address range, 224.0.0.0 thru 239.255.255.255, that is, it's a class D address. {return (addr[0] & 0xF0)==0xE0;}

bool IPAddress::isNetwork (  const IPAddress &  toCmp  )  const

Indicates if the address is from the same network { switch (getIPClass()) { case 'A': if (addr[0] == toCmp.addr[0]) return true; break; case 'B': if ((addr[0] == toCmp.addr[0]) && (addr[1] == toCmp.addr[1])) return true; break; case 'C': if ((addr[0] == toCmp.addr[0]) && (addr[1] == toCmp.addr[1]) && (addr[2] == toCmp.addr[2])) return true; break; default: // Class D or E return false; } // not equal return false; }

bool IPAddress::isUnspecified (   )  const [inline]

True if all four address bytes are zero. The null value is customarily used to represent a missing, unspecified or invalid address in the simulation models. {return !addr[0] && !addr[1] && !addr[2] && !addr[3];}

bool IPAddress::isWellFormed (  const char *  text  )  [static]

Returns true if the format of the string corresponds to an IP address with the dotted notation ("192.66.86.1"), and false otherwise. This function can be used to verify an IP address string before assigning it to an IPAddress object (both its ctor and set() function raises an error if the string has invalid format.) { unsigned char dummy[4]; return parseIPAddress(text, dummy); }

void IPAddress::keepFirstBits (  unsigned int  n  )  [protected]

{ if (n > 31) return; int len_bytes = n / 8; uint32 mask = 0xFF; mask = ~(mask >> ((n - (len_bytes * 8)))); addr[len_bytes] = addr[len_bytes] & mask; for (int i = len_bytes+1; i < 4; i++) addr[i] = 0; }

bool IPAddress::maskedAddrAreEqual (  const IPAddress &  addr1, const IPAddress &  addr2, const IPAddress &  netmask )  [static]

Test if the masked addresses (ie the mask is applied to addr1 and addr2) are equal. { if (addr1.doAnd(netmask).equals(addr2.doAnd(netmask))) return true; return false; }

int IPAddress::netmaskLength (   )  const

Counts 1 bits in a netmask. E.g. for 255.255.254.0, it will return 23. { uint32 addr = getInt(); int i; for (i=0; i<31; i++) if (addr & (1 << i)) return 32-i; return 0; }

int IPAddress::numMatchingPrefixBits (  const IPAddress &  to_cmp  )  const

Indicates how many bits from the to_cmp address, starting counting from the left, matches the address. E.g. if the address is 130.206.72.237, and to_cmp 130.206.72.0, 24 will be returned. Typical usage for comparing IP prefixes. { uint32 addr1 = getInt(); uint32 addr2 = to_cmp.getInt(); uint32 res = addr1 ^ addr2; // If the bits are equal, there is a 0, so counting // the zeros from the left int i; for (i = 31; i >= 0; i--) { if (res & (1 << i)) { // 1, means not equal, so stop return 31 - i; } } return 32; }

bool IPAddress::operator!= (  const IPAddress &  addr1  )  const [inline]

Returns !equals(addr). {return !equals(addr1);}

bool IPAddress::operator< (  const IPAddress &  addr1  )  const [inline]

Compares two IP addresses. {return getInt()<addr1.getInt();}

IPAddress & IPAddress::operator= (  const IPAddress &  obj  )

Assignment { addr[0] = obj.addr[0]; addr[1] = obj.addr[1]; addr[2] = obj.addr[2]; addr[3] = obj.addr[3]; return *this; }

bool IPAddress::operator== (  const IPAddress &  addr1  )  const [inline]

Returns equals(addr). {return equals(addr1);}

bool IPAddress::parseIPAddress (  const char *  text, unsigned char  tobytes[] )  [static, protected]

{ if (!text) return false; if (!strcmp(text,"<unspec>")) { tobytes[0] = tobytes[1] = tobytes[2] = tobytes[3] = 0; return true; } const char *s = text; int i=0; while(true) { if (*s<'0' || *s>'9') return false; // missing number // read and store number int num = 0; while (*s>='0' && *s<='9') num = 10*num + (*s++ - '0'); if (num>255) return false; // number too big tobytes[i++] = (unsigned char) num; if (!*s) break; // end of string if (*s!='.') return false; // invalid char after number if (i==4) return false; // read 4th number and not yet EOS // skip '.' s++; } return i==4; // must have all 4 numbers }

bool IPAddress::prefixMatches (  const IPAddress &  to_cmp, int  numbits )  const

Compares the first numbits bits of the two addresses. { if (numbits<1) return true; uint32 addr1 = getInt(); uint32 addr2 = to_cmp.getInt(); if (numbits > 31) return addr1==addr2; // The right shift on an unsigned int produces 0 on the left uint32 mask = 0xFFFFFFFF; mask = ~(mask >> numbits); return (addr1 & mask) == (addr2 & mask); }

void IPAddress::set (  const char *  t  )

IP address given as text: "192.66.86.1" { if (!text) opp_error("IP address string is NULL"); bool ok = parseIPAddress(text, addr); if (!ok) opp_error("Invalid IP address string `%s'", text); }

void IPAddress::set (  int  i0, int  i1, int  i2, int  i3 )

IP address bytes: "i0.i1.i2.i3" format { addr[0] = i0; addr[1] = i1; addr[2] = i2; addr[3] = i3; }

void IPAddress::set (  uint32  i  )

IP address as int { addr[0] = (ip >> 24) & 0xFF; addr[1] = (ip >> 16) & 0xFF; addr[2] = (ip >> 8) & 0xFF; addr[3] = ip & 0xFF; }

std::string IPAddress::str (   )  const

Returns the string representation of the address (e.g. "152.66.86.92") { if (isUnspecified()) return std::string("<unspec>"); char buf[ADDRESS_STRING_SIZE]; sprintf(buf, "%d.%d.%d.%d", addr[0], addr[1], addr[2], addr[3]); return std::string(buf); }

---

Member Data Documentation

unsigned char IPAddress::addr[4] [protected]

const IPAddress IPAddress::ALL_DVMRP_ROUTERS_MCAST [static]

224.0.0.4 All DVMRP routers

const IPAddress IPAddress::ALL_HOSTS_MCAST [static]

224.0.0.1 All hosts on a subnet

const IPAddress IPAddress::ALL_OSPF_DESIGNATED_ROUTERS_MCAST [static]

224.0.0.6 All OSPF Designated Routers

const IPAddress IPAddress::ALL_OSPF_ROUTERS_MCAST [static]

224.0.0.5 All OSPF routers (DR Others)

const IPAddress IPAddress::ALL_ROUTERS_MCAST [static]

224.0.0.2 All routers on a subnet

const IPAddress IPAddress::ALLONES_ADDRESS [static]

255.255.255.255

const IPAddress IPAddress::LOOPBACK_ADDRESS [static]

127.0.0.1

const IPAddress IPAddress::LOOPBACK_NETMASK [static]

255.0.0.0

const IPAddress IPAddress::UNSPECIFIED_ADDRESS [static]

0.0.0.0

---

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

• IPAddress.h
• IPAddress.cc

---