Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages
Network / OSPFv2 / Router

OSPFcommon.h File Reference

#include <ctype.h>
#include <stdio.h>
#include <functional>

Namespaces

namespace  OSPF

Defines

#define LS_REFRESH_TIME   1800
#define MIN_LS_INTERVAL   5
#define MIN_LS_ARRIVAL   1
#define MAX_AGE   3600
#define CHECK_AGE   300
#define MAX_AGE_DIFF   900
#define LS_INFINITY   16777215
#define DEFAULT_DESTINATION_ADDRESS   0
#define DEFAULT_DESTINATION_MASK   0
#define INITIAL_SEQUENCE_NUMBER   -2147483647
#define MAX_SEQUENCE_NUMBER   2147483647
#define VIRTUAL_LINK_TTL   32
#define IPV4_HEADER_LENGTH   60
#define IPV4_DATAGRAM_LENGTH   65536
#define OSPF_HEADER_LENGTH   24
#define OSPF_LSA_HEADER_LENGTH   20
#define OSPF_DD_HEADER_LENGTH   8
#define OSPF_REQUEST_LENGTH   12
#define OSPF_ROUTERLSA_HEADER_LENGTH   4
#define OSPF_LINK_HEADER_LENGTH   12
#define OSPF_TOS_LENGTH   4
#define OSPF_NETWORKLSA_MASK_LENGTH   4
#define OSPF_NETWORKLSA_ADDRESS_LENGTH   4
#define OSPF_SUMMARYLSA_HEADER_LENGTH   8
#define OSPF_ASEXTERNALLSA_HEADER_LENGTH   16
#define OSPF_ASEXTERNALLSA_TOS_INFO_LENGTH   12

Typedefs

typedef unsigned long Metric
typedef unsigned long RouterID
typedef unsigned long AreaID
typedef unsigned long LinkStateID

Enumerations

enum  AuthenticationType { NullType = 0, SimplePasswordType = 1, CrytographicType = 2 }

Functions

bool operator== (OSPF::DesignatedRouterID leftID, OSPF::DesignatedRouterID rightID)
bool operator!= (OSPF::DesignatedRouterID leftID, OSPF::DesignatedRouterID rightID)
bool operator== (OSPF::IPv4Address leftAddress, OSPF::IPv4Address rightAddress)
bool operator!= (OSPF::IPv4Address leftAddress, OSPF::IPv4Address rightAddress)
bool operator< (OSPF::IPv4Address leftAddress, OSPF::IPv4Address rightAddress)
bool operator<= (OSPF::IPv4Address leftAddress, OSPF::IPv4Address rightAddress)
bool operator> (OSPF::IPv4Address leftAddress, OSPF::IPv4Address rightAddress)
bool operator>= (OSPF::IPv4Address leftAddress, OSPF::IPv4Address rightAddress)
OSPF::IPv4Address operator & (OSPF::IPv4Address address, OSPF::IPv4Address mask)
OSPF::IPv4Address operator| (OSPF::IPv4Address address, OSPF::IPv4Address match)
bool operator== (OSPF::IPv4AddressRange leftAddressRange, OSPF::IPv4AddressRange rightAddressRange)
bool operator!= (OSPF::IPv4AddressRange leftAddressRange, OSPF::IPv4AddressRange rightAddressRange)
OSPF::IPv4Address IPv4AddressFromAddressString (const char *charForm)
OSPF::IPv4Address IPv4AddressFromULong (unsigned long longForm)
unsigned long ULongFromIPv4Address (OSPF::IPv4Address byteForm)
unsigned long ULongFromAddressString (const char *charForm)
char * AddressStringFromIPv4Address (char *buffer, int bufferLength, OSPF::IPv4Address byteForm)
char * AddressStringFromULong (char *buffer, int bufferLength, unsigned long longForm)
char HexCharToByte (char hex)
char HexPairToByte (char upperHex, char lowerHex)

Variables

const RouterID NullRouterID = 0
const AreaID BackboneAreaID = 0
const LinkStateID NullLinkStateID = 0
const IPv4Address NullIPv4Address = { {0, 0, 0, 0} }
const IPv4Address AllSPFRouters = { {224, 0, 0, 5} }
const IPv4Address AllDRouters = { {224, 0, 0, 6} }
const IPv4AddressRange NullIPv4AddressRange = { { {0, 0, 0, 0} }, { {0, 0, 0, 0} } }
const DesignatedRouterID NullDesignatedRouterID = { 0, { {0, 0, 0, 0} } }

Define Documentation

#define CHECK_AGE   300
 

#define DEFAULT_DESTINATION_ADDRESS   0
 

#define DEFAULT_DESTINATION_MASK   0
 

#define INITIAL_SEQUENCE_NUMBER   -2147483647
 

#define IPV4_DATAGRAM_LENGTH   65536
 

#define IPV4_HEADER_LENGTH   60
 

#define LS_INFINITY   16777215
 

#define LS_REFRESH_TIME   1800
 

#define MAX_AGE   3600
 

#define MAX_AGE_DIFF   900
 

#define MAX_SEQUENCE_NUMBER   2147483647
 

#define MIN_LS_ARRIVAL   1
 

#define MIN_LS_INTERVAL   5
 

#define OSPF_ASEXTERNALLSA_HEADER_LENGTH   16
 

#define OSPF_ASEXTERNALLSA_TOS_INFO_LENGTH   12
 

#define OSPF_DD_HEADER_LENGTH   8
 

#define OSPF_HEADER_LENGTH   24
 

#define OSPF_LINK_HEADER_LENGTH   12
 

#define OSPF_LSA_HEADER_LENGTH   20
 

#define OSPF_NETWORKLSA_ADDRESS_LENGTH   4
 

#define OSPF_NETWORKLSA_MASK_LENGTH   4
 

#define OSPF_REQUEST_LENGTH   12
 

#define OSPF_ROUTERLSA_HEADER_LENGTH   4
 

#define OSPF_SUMMARYLSA_HEADER_LENGTH   8
 

#define OSPF_TOS_LENGTH   4
 

#define VIRTUAL_LINK_TTL   32
 

Typedef Documentation

typedef unsigned long OSPF::AreaID
 

typedef unsigned long OSPF::LinkStateID
 

typedef unsigned long OSPF::Metric
 

typedef unsigned long OSPF::RouterID
 

Enumeration Type Documentation

enum OSPF::AuthenticationType
 

Enumeration values:
NullType 
SimplePasswordType 
CrytographicType  
00041                         {
00042     NullType           = 0,
00043     SimplePasswordType = 1,
00044     CrytographicType   = 2
00045 };

Function Documentation

char* AddressStringFromIPv4Address (  char *  buffer,
int  bufferLength,
OSPF::IPv4Address  byteForm
)  [inline]
  

00286 {
00287     if (bufferLength < 16) {
00288         buffer = '\0';
00289     }
00290     else {
00291         sprintf (buffer, "%d.%d.%d.%d", byteForm.bytes[0], byteForm.bytes[1], byteForm.bytes[2], byteForm.bytes[3]);
00292     }
00293     return buffer;
00294 }

char* AddressStringFromULong (  char *  buffer,
int  bufferLength,
unsigned long  longForm
)  [inline]
  

00297 {
00298     if (bufferLength < 16) {
00299         buffer = '\0';
00300     }
00301     else {
00302         sprintf (buffer, "%d.%d.%d.%d", (int)((longForm & 0xFF000000) >> 24),
00303                                         (int)((longForm & 0x00FF0000) >> 16),
00304                                         (int)((longForm & 0x0000FF00) >> 8),
00305                                         (int)(longForm & 0x000000FF));
00306     }
00307     return buffer;
00308 }

char HexCharToByte (  char  hex  )  [inline]
  

00311 {
00312     switch (hex) {
00313         case '0':   return 0;
00314         case '1':   return 1;
00315         case '2':   return 2;
00316         case '3':   return 3;
00317         case '4':   return 4;
00318         case '5':   return 5;
00319         case '6':   return 6;
00320         case '7':   return 7;
00321         case '8':   return 8;
00322         case '9':   return 9;
00323         case 'A':   return 10;
00324         case 'B':   return 11;
00325         case 'C':   return 12;
00326         case 'D':   return 13;
00327         case 'E':   return 14;
00328         case 'F':   return 15;
00329         case 'a':   return 10;
00330         case 'b':   return 11;
00331         case 'c':   return 12;
00332         case 'd':   return 13;
00333         case 'e':   return 14;
00334         case 'f':   return 15;
00335         default:    return 0;
00336     };
00337 }

char HexPairToByte (  char  upperHex,
char  lowerHex
)  [inline]
  

00340 {
00341     return ((HexCharToByte (upperHex) << 4) & (HexCharToByte (lowerHex)));
00342 }

OSPF::IPv4Address IPv4AddressFromAddressString (  const char *  charForm  )  [inline]
  

00219 {
00220     OSPF::IPv4Address byteForm = OSPF::NullIPv4Address;
00221 
00222     int  lastDot = -1;
00223     int  byteCount = 0;
00224     for (int i = 0; i < 16; i++) {
00225         if (charForm[i] == '\0') {
00226             if ((byteCount <= 3) && (i - lastDot - 1 <= 3)) {
00227                 switch (i - lastDot - 1) {
00228                     case 3: byteForm.bytes[byteCount] += (((charForm[i - 3] - '0') < 3) ? (charForm[i - 3] - '0') : 0) * 100;
00229                     case 2: byteForm.bytes[byteCount] += (charForm[i - 2] - '0') * 10;
00230                     case 1: byteForm.bytes[byteCount] += charForm[i - 1] - '0';
00231                     default: break;
00232                 }
00233             }
00234             break;
00235         }
00236         if ((!isdigit (charForm[i])) && (charForm[i] != '.')) {
00237             break;
00238         }
00239         if (charForm[i] == '.') {
00240             if (i == 0) {
00241                 break;
00242             }
00243             if (i - lastDot - 1 > 3) {
00244                 break;
00245             }
00246             switch (i - lastDot - 1) {
00247                 case 3: byteForm.bytes[byteCount] += (((charForm[i - 3] - '0') < 3) ? (charForm[i - 3] - '0') : 0) * 100;
00248                 case 2: byteForm.bytes[byteCount] += (charForm[i - 2] - '0') * 10;
00249                 case 1: byteForm.bytes[byteCount] += charForm[i - 1] - '0';
00250                 default: break;
00251             }
00252             byteCount++;
00253             lastDot = i;
00254             if (byteCount > 3) {
00255                 break;
00256             }
00257         }
00258     }
00259 
00260     return byteForm;
00261 }

OSPF::IPv4Address IPv4AddressFromULong (  unsigned long  longForm  )  [inline]
  

00264 {
00265 
00266     OSPF::IPv4Address byteForm;
00267 
00268     byteForm.bytes[0] = (longForm & 0xFF000000) >> 24;
00269     byteForm.bytes[1] = (longForm & 0x00FF0000) >> 16;
00270     byteForm.bytes[2] = (longForm & 0x0000FF00) >> 8;
00271     byteForm.bytes[3] =  longForm & 0x000000FF;
00272     return byteForm;
00273 }

OSPF::IPv4Address operator & (  OSPF::IPv4Address  address,
OSPF::IPv4Address  mask
)  [inline]
  

00169 {
00170     OSPF::IPv4Address maskedAddress;
00171     maskedAddress.bytes[0] = address.bytes[0] & mask.bytes[0];
00172     maskedAddress.bytes[1] = address.bytes[1] & mask.bytes[1];
00173     maskedAddress.bytes[2] = address.bytes[2] & mask.bytes[2];
00174     maskedAddress.bytes[3] = address.bytes[3] & mask.bytes[3];
00175     return maskedAddress;
00176 }

bool operator!= (  OSPF::IPv4AddressRange  leftAddressRange,
OSPF::IPv4AddressRange  rightAddressRange
)  [inline]
  

00195 {
00196     return (!(leftAddressRange == rightAddressRange));
00197 }

bool operator!= (  OSPF::IPv4Address  leftAddress,
OSPF::IPv4Address  rightAddress
)  [inline]
  

00132 {
00133     return (!(leftAddress == rightAddress));
00134 }

bool operator!= (  OSPF::DesignatedRouterID  leftID,
OSPF::DesignatedRouterID  rightID
)  [inline]
  

00119 {
00120     return (!(leftID == rightID));
00121 }

bool operator< (  OSPF::IPv4Address  leftAddress,
OSPF::IPv4Address  rightAddress
)  [inline]
  

00137 {
00138     if (leftAddress.bytes[0] < rightAddress.bytes[0]) {
00139         return true;
00140     }
00141     if (leftAddress.bytes[1] < rightAddress.bytes[1]) {
00142         return true;
00143     }
00144     if (leftAddress.bytes[2] < rightAddress.bytes[2]) {
00145         return true;
00146     }
00147     if (leftAddress.bytes[3] < rightAddress.bytes[3]) {
00148         return true;
00149     }
00150     return false;
00151 }

bool operator<= (  OSPF::IPv4Address  leftAddress,
OSPF::IPv4Address  rightAddress
)  [inline]
  

00154 {
00155     return ((leftAddress < rightAddress) || (leftAddress == rightAddress));
00156 }

bool operator== (  OSPF::IPv4AddressRange  leftAddressRange,
OSPF::IPv4AddressRange  rightAddressRange
)  [inline]
  

00189 {
00190     return (leftAddressRange.address == rightAddressRange.address &&
00191             leftAddressRange.mask    == rightAddressRange.mask);
00192 }

bool operator== (  OSPF::IPv4Address  leftAddress,
OSPF::IPv4Address  rightAddress
)  [inline]
  

00124 {
00125     return (leftAddress.bytes[0] == rightAddress.bytes[0] &&
00126             leftAddress.bytes[1] == rightAddress.bytes[1] &&
00127             leftAddress.bytes[2] == rightAddress.bytes[2] &&
00128             leftAddress.bytes[3] == rightAddress.bytes[3]);
00129 }

bool operator== (  OSPF::DesignatedRouterID  leftID,
OSPF::DesignatedRouterID  rightID
)  [inline]
  

00110 {
00111     return (leftID.routerID == rightID.routerID &&
00112             leftID.ipInterfaceAddress.bytes[0] == rightID.ipInterfaceAddress.bytes[0] &&
00113             leftID.ipInterfaceAddress.bytes[1] == rightID.ipInterfaceAddress.bytes[1] &&
00114             leftID.ipInterfaceAddress.bytes[2] == rightID.ipInterfaceAddress.bytes[2] &&
00115             leftID.ipInterfaceAddress.bytes[3] == rightID.ipInterfaceAddress.bytes[3]);
00116 }

bool operator> (  OSPF::IPv4Address  leftAddress,
OSPF::IPv4Address  rightAddress
)  [inline]
  

00159 {
00160     return (!(leftAddress <= rightAddress));
00161 }

bool operator>= (  OSPF::IPv4Address  leftAddress,
OSPF::IPv4Address  rightAddress
)  [inline]
  

00164 {
00165     return (!(leftAddress < rightAddress));
00166 }

OSPF::IPv4Address operator| (  OSPF::IPv4Address  address,
OSPF::IPv4Address  match
)  [inline]
  

00179 {
00180     OSPF::IPv4Address matchAddress;
00181     matchAddress.bytes[0] = address.bytes[0] | match.bytes[0];
00182     matchAddress.bytes[1] = address.bytes[1] | match.bytes[1];
00183     matchAddress.bytes[2] = address.bytes[2] | match.bytes[2];
00184     matchAddress.bytes[3] = address.bytes[3] | match.bytes[3];
00185     return matchAddress;
00186 }

unsigned long ULongFromAddressString (  const char *  charForm  )  [inline]
  

00281 {
00282     return ULongFromIPv4Address (IPv4AddressFromAddressString (charForm));
00283 }

unsigned long ULongFromIPv4Address (  OSPF::IPv4Address  byteForm  )  [inline]
  

00276 {
00277     return ((byteForm.bytes[0] << 24) + (byteForm.bytes[1] << 16) + (byteForm.bytes[2] << 8) + byteForm.bytes[3]);
00278 }

Variable Documentation

const IPv4Address OSPF::AllDRouters = { {224, 0, 0, 6} }
 

const IPv4Address OSPF::AllSPFRouters = { {224, 0, 0, 5} }
 

const AreaID OSPF::BackboneAreaID = 0
 

const DesignatedRouterID OSPF::NullDesignatedRouterID = { 0, { {0, 0, 0, 0} } }
 

const IPv4Address OSPF::NullIPv4Address = { {0, 0, 0, 0} }
 

const IPv4AddressRange OSPF::NullIPv4AddressRange = { { {0, 0, 0, 0} }, { {0, 0, 0, 0} } }
 

const LinkStateID OSPF::NullLinkStateID = 0
 

const RouterID OSPF::NullRouterID = 0
 

Generated on Sat Apr 1 20:52:20 2006 for INET Framework for OMNeT++/OMNEST by  doxygen 1.4.1