Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages
OSPF::Interface

OSPF::Interface Class Reference

#include <OSPFInterface.h>

List of all members.

Public Types

enum  InterfaceEventType {
  InterfaceUp = 0, HelloTimer = 1, WaitTimer = 2, AcknowledgementTimer = 3,
  BackupSeen = 4, NeighborChange = 5, LoopIndication = 6, UnloopIndication = 7,
  InterfaceDown = 8
}
enum  OSPFInterfaceType {
  UnknownType = 0, PointToPoint = 1, Broadcast = 2, NBMA = 3,
  PointToMultiPoint = 4, Virtual = 5
}
enum  InterfaceStateType {
  DownState = 0, LoopbackState = 1, WaitingState = 2, PointToPointState = 3,
  NotDesignatedRouterState = 4, BackupState = 5, DesignatedRouterState = 6
}

Public Member Functions

 Interface (OSPFInterfaceType ifType=UnknownType)
virtual ~Interface (void)
void ProcessEvent (InterfaceEventType event)
void Reset (void)
void SendHelloPacket (IPv4Address destination, short ttl=1)
void SendLSAcknowledgement (OSPFLSAHeader *lsaHeader, IPv4Address destination)
Neighbor * GetNeighborByID (RouterID neighborID)
Neighbor * GetNeighborByAddress (IPv4Address address)
void AddNeighbor (Neighbor *neighbor)
InterfaceStateType GetState (void) const
bool AnyNeighborInStates (int states) const
void RemoveFromAllRetransmissionLists (LSAKeyType lsaKey)
bool IsOnAnyRetransmissionList (LSAKeyType lsaKey) const
bool FloodLSA (OSPFLSA *lsa, Interface *intf=NULL, Neighbor *neighbor=NULL)
void AddDelayedAcknowledgement (OSPFLSAHeader &lsaHeader)
void SendDelayedAcknowledgements (void)
void AgeTransmittedLSALists (void)
OSPFLinkStateUpdatePacket * CreateUpdatePacket (OSPFLSA *lsa)
void SetType (OSPFInterfaceType ifType)
OSPFInterfaceType GetType (void) const
void SetIfIndex (unsigned char index)
unsigned char GetIfIndex (void) const
void SetMTU (unsigned short ifMTU)
unsigned short GetMTU (void) const
void SetAreaID (AreaID areaId)
AreaID GetAreaID (void) const
void SetOutputCost (Metric cost)
Metric GetOutputCost (void) const
void SetRetransmissionInterval (short interval)
short GetRetransmissionInterval (void) const
void SetTransmissionDelay (short delay)
short GetTransmissionDelay (void) const
void SetAcknowledgementDelay (short delay)
short GetAcknowledgementDelay (void) const
void SetRouterPriority (unsigned char priority)
unsigned char GetRouterPriority (void) const
void SetHelloInterval (short interval)
short GetHelloInterval (void) const
void SetPollInterval (short interval)
short GetPollInterval (void) const
void SetRouterDeadInterval (short interval)
short GetRouterDeadInterval (void) const
void SetAuthenticationType (AuthenticationType type)
AuthenticationType GetAuthenticationType (void) const
void SetAuthenticationKey (AuthenticationKeyType key)
AuthenticationKeyType GetAuthenticationKey (void) const
void SetAddressRange (IPv4AddressRange range)
IPv4AddressRange GetAddressRange (void) const
OSPFTimer * GetHelloTimer (void)
OSPFTimer * GetWaitTimer (void)
OSPFTimer * GetAcknowledgementTimer (void)
DesignatedRouterID GetDesignatedRouter (void) const
DesignatedRouterID GetBackupDesignatedRouter (void) const
unsigned long GetNeighborCount (void) const
Neighbor * GetNeighbor (unsigned long i)
const Neighbor * GetNeighbor (unsigned long i) const
void SetArea (Area *area)
Area * GetArea (void)
const Area * GetArea (void) const

Static Public Member Functions

static const char * GetStateString (InterfaceStateType stateType)

Private Member Functions

void ChangeState (InterfaceState *newState, InterfaceState *currentState)

Private Attributes

OSPFInterfaceType interfaceType
InterfaceState * state
InterfaceState * previousState
unsigned char ifIndex
unsigned short mtu
IPv4AddressRange interfaceAddressRange
AreaID areaID
short helloInterval
short pollInterval
short routerDeadInterval
short interfaceTransmissionDelay
unsigned char routerPriority
OSPFTimer * helloTimer
OSPFTimer * waitTimer
OSPFTimer * acknowledgementTimer
std::map< RouterID, Neighbor * > neighboringRoutersByID
std::map< IPv4Address, Neighbor *,
IPv4Address_Less > 		neighboringRoutersByAddress
std::vector< Neighbor * > neighboringRouters
std::map< IPv4Address, std::list<
OSPFLSAHeader >, IPv4Address_Less > 		delayedAcknowledgements
DesignatedRouterID designatedRouter
DesignatedRouterID backupDesignatedRouter
Metric interfaceOutputCost
short retransmissionInterval
short acknowledgementDelay
AuthenticationType authenticationType
AuthenticationKeyType authenticationKey
Area * parentArea

Friends

class InterfaceState

Member Enumeration Documentation

enum OSPF::Interface::InterfaceEventType
 

Enumeration values:
InterfaceUp 
HelloTimer 
WaitTimer 
AcknowledgementTimer 
BackupSeen 
NeighborChange 
LoopIndication 
UnloopIndication 
InterfaceDown  
00018                             {
00019         InterfaceUp          = 0,
00020         HelloTimer           = 1,
00021         WaitTimer            = 2,
00022         AcknowledgementTimer = 3,
00023         BackupSeen           = 4,
00024         NeighborChange       = 5,
00025         LoopIndication       = 6,
00026         UnloopIndication     = 7,
00027         InterfaceDown        = 8
00028     };

enum OSPF::Interface::InterfaceStateType
 

Enumeration values:
DownState 
LoopbackState 
WaitingState 
PointToPointState 
NotDesignatedRouterState 
BackupState 
DesignatedRouterState  
00039                             {
00040         DownState                = 0,
00041         LoopbackState            = 1,
00042         WaitingState             = 2,
00043         PointToPointState        = 3,
00044         NotDesignatedRouterState = 4,
00045         BackupState              = 5,
00046         DesignatedRouterState    = 6
00047     };

enum OSPF::Interface::OSPFInterfaceType
 

Enumeration values:
UnknownType 
PointToPoint 
Broadcast 
NBMA 
PointToMultiPoint 
Virtual  
00030                            {
00031         UnknownType       = 0,
00032         PointToPoint      = 1,
00033         Broadcast         = 2,
00034         NBMA              = 3,
00035         PointToMultiPoint = 4,
00036         Virtual           = 5
00037     };

Constructor & Destructor Documentation

OSPF::Interface::Interface (  OSPFInterfaceType  ifType = UnknownType  ) 
  

00011                                                                :
00012     interfaceType (ifType),
00013     ifIndex (0),
00014     mtu (0),
00015     interfaceAddressRange (OSPF::NullIPv4AddressRange),
00016     areaID (OSPF::BackboneAreaID),
00017     helloInterval (10),
00018     pollInterval (120),
00019     routerDeadInterval (40),
00020     interfaceTransmissionDelay (1),
00021     routerPriority (0),
00022     designatedRouter (OSPF::NullDesignatedRouterID),
00023     backupDesignatedRouter (OSPF::NullDesignatedRouterID),
00024     interfaceOutputCost (1),
00025     retransmissionInterval (5),
00026     acknowledgementDelay (1),
00027     authenticationType (OSPF::NullType),
00028     parentArea (NULL)
00029 {
00030     state = new OSPF::InterfaceStateDown;
00031     previousState = NULL;
00032     helloTimer = new OSPFTimer;
00033     helloTimer->setTimerKind (InterfaceHelloTimer);
00034     helloTimer->setContextPointer (this);
00035     helloTimer->setName ("OSPF::Interface::InterfaceHelloTimer");
00036     waitTimer = new OSPFTimer;
00037     waitTimer->setTimerKind (InterfaceWaitTimer);
00038     waitTimer->setContextPointer (this);
00039     waitTimer->setName ("OSPF::Interface::InterfaceWaitTimer");
00040     acknowledgementTimer = new OSPFTimer;
00041     acknowledgementTimer->setTimerKind (InterfaceAcknowledgementTimer);
00042     acknowledgementTimer->setContextPointer (this);
00043     acknowledgementTimer->setName ("OSPF::Interface::InterfaceAcknowledgementTimer");
00044     memset (authenticationKey.bytes, 0, 8 * sizeof (char));
00045 }

OSPF::Interface::~Interface (  void   )  [virtual]
  

00048 {
00049     MessageHandler* messageHandler = parentArea->GetRouter ()->GetMessageHandler ();
00050     messageHandler->ClearTimer (helloTimer);
00051     delete helloTimer;
00052     messageHandler->ClearTimer (waitTimer);
00053     delete waitTimer;
00054     messageHandler->ClearTimer (acknowledgementTimer);
00055     delete acknowledgementTimer;
00056     if (previousState != NULL) {
00057         delete previousState;
00058     }
00059     delete state;
00060     long neighborCount = neighboringRouters.size ();
00061     for (long i = 0; i < neighborCount; i++) {
00062         delete neighboringRouters[i];
00063     }
00064 }

Member Function Documentation

void OSPF::Interface::AddDelayedAcknowledgement (  OSPFLSAHeader &  lsaHeader  ) 
  

00478 {
00479     if (interfaceType == OSPF::Interface::Broadcast) {
00480         if ((GetState () == OSPF::Interface::DesignatedRouterState) ||
00481             (GetState () == OSPF::Interface::BackupState) ||
00482             (designatedRouter == OSPF::NullDesignatedRouterID))
00483         {
00484             delayedAcknowledgements[OSPF::AllSPFRouters].push_back (lsaHeader);
00485         } else {
00486             delayedAcknowledgements[OSPF::AllDRouters].push_back (lsaHeader);
00487         }
00488     } else {
00489         long neighborCount = neighboringRouters.size ();
00490         for (long i = 0; i < neighborCount; i++) {
00491             if (neighboringRouters[i]->GetState () >= OSPF::Neighbor::ExchangeState) {
00492                 delayedAcknowledgements[neighboringRouters[i]->GetAddress ()].push_back (lsaHeader);
00493             }
00494         }
00495     }
00496 }

void OSPF::Interface::AddNeighbor (  Neighbor *  neighbor  ) 
  

00199 {
00200     neighboringRoutersByID[neighbor->GetNeighborID ()] = neighbor;
00201     neighboringRoutersByAddress[neighbor->GetAddress ()] = neighbor;
00202     neighbor->SetInterface (this);
00203     neighboringRouters.push_back (neighbor);
00204 }

void OSPF::Interface::AgeTransmittedLSALists (  void   ) 
  

00557 {
00558     long neighborCount = neighboringRouters.size ();
00559     for (long i = 0; i < neighborCount; i++) {
00560         neighboringRouters[i]->AgeTransmittedLSAList ();
00561     }
00562 }

bool OSPF::Interface::AnyNeighborInStates (  int  states  )  const
  

00227 {
00228     long neighborCount = neighboringRouters.size ();
00229     for (long i = 0; i < neighborCount; i++) {
00230         OSPF::Neighbor::NeighborStateType neighborState = neighboringRouters[i]->GetState ();
00231         if (neighborState & states) {
00232             return true;
00233         }
00234     }
00235     return false;
00236 }

void OSPF::Interface::ChangeState (  InterfaceState *  newState,
InterfaceState *  currentState
)  [private]
  

00078 {
00079     if (previousState != NULL) {
00080         delete previousState;
00081     }
00082     state = newState;
00083     previousState = currentState;
00084 }

OSPFLinkStateUpdatePacket * OSPF::Interface::CreateUpdatePacket (  OSPFLSA *  lsa  ) 
  

00391 {
00392     LSAType lsaType                  = static_cast<LSAType> (lsa->getHeader ().getLsType ());
00393     OSPFRouterLSA* routerLSA         = (lsaType == RouterLSAType) ? dynamic_cast<OSPFRouterLSA*> (lsa) : NULL;
00394     OSPFNetworkLSA* networkLSA       = (lsaType == NetworkLSAType) ? dynamic_cast<OSPFNetworkLSA*> (lsa) : NULL;
00395     OSPFSummaryLSA* summaryLSA       = ((lsaType == SummaryLSA_NetworksType) ||
00396                                         (lsaType == SummaryLSA_ASBoundaryRoutersType)) ? dynamic_cast<OSPFSummaryLSA*> (lsa) : NULL;
00397     OSPFASExternalLSA* asExternalLSA = (lsaType == ASExternalLSAType) ? dynamic_cast<OSPFASExternalLSA*> (lsa) : NULL;
00398 
00399     if (((lsaType == RouterLSAType) && (routerLSA != NULL)) ||
00400         ((lsaType == NetworkLSAType) && (networkLSA != NULL)) ||
00401         (((lsaType == SummaryLSA_NetworksType) || (lsaType == SummaryLSA_ASBoundaryRoutersType)) && (summaryLSA != NULL)) ||
00402         ((lsaType == ASExternalLSAType) && (asExternalLSA != NULL)))
00403     {
00404         OSPFLinkStateUpdatePacket* updatePacket = new OSPFLinkStateUpdatePacket;
00405 
00406         updatePacket->setType (LinkStateUpdatePacket);
00407         updatePacket->setRouterID (parentArea->GetRouter ()->GetRouterID ());
00408         updatePacket->setAreaID (areaID);
00409         updatePacket->setAuthenticationType (authenticationType);
00410         for (int j = 0; j < 8; j++) {
00411             updatePacket->setAuthentication (j, authenticationKey.bytes[j]);
00412         }
00413 
00414         updatePacket->setNumberOfLSAs (1);
00415 
00416         switch (lsaType) {
00417             case RouterLSAType:
00418                 {
00419                     updatePacket->setRouterLSAsArraySize (1);
00420                     updatePacket->setRouterLSAs (0, *routerLSA);
00421                     unsigned short lsAge = updatePacket->getRouterLSAs (0).getHeader ().getLsAge ();
00422                     if (lsAge < MAX_AGE - interfaceTransmissionDelay) {
00423                         updatePacket->getRouterLSAs (0).getHeader ().setLsAge (lsAge + interfaceTransmissionDelay);
00424                     } else {
00425                         updatePacket->getRouterLSAs (0).getHeader ().setLsAge (MAX_AGE);
00426                     }
00427                 }
00428                 break;
00429             case NetworkLSAType:
00430                 {
00431                     updatePacket->setNetworkLSAsArraySize (1);
00432                     updatePacket->setNetworkLSAs (0, *networkLSA);
00433                     unsigned short lsAge = updatePacket->getNetworkLSAs (0).getHeader ().getLsAge ();
00434                     if (lsAge < MAX_AGE - interfaceTransmissionDelay) {
00435                         updatePacket->getNetworkLSAs (0).getHeader ().setLsAge (lsAge + interfaceTransmissionDelay);
00436                     } else {
00437                         updatePacket->getNetworkLSAs (0).getHeader ().setLsAge (MAX_AGE);
00438                     }
00439                 }
00440                 break;
00441             case SummaryLSA_NetworksType:
00442             case SummaryLSA_ASBoundaryRoutersType:
00443                 {
00444                     updatePacket->setSummaryLSAsArraySize (1);
00445                     updatePacket->setSummaryLSAs (0, *summaryLSA);
00446                     unsigned short lsAge = updatePacket->getSummaryLSAs (0).getHeader ().getLsAge ();
00447                     if (lsAge < MAX_AGE - interfaceTransmissionDelay) {
00448                         updatePacket->getSummaryLSAs (0).getHeader ().setLsAge (lsAge + interfaceTransmissionDelay);
00449                     } else {
00450                         updatePacket->getSummaryLSAs (0).getHeader ().setLsAge (MAX_AGE);
00451                     }
00452                 }
00453                 break;
00454             case ASExternalLSAType:
00455                 {
00456                     updatePacket->setAsExternalLSAsArraySize (1);
00457                     updatePacket->setAsExternalLSAs (0, *asExternalLSA);
00458                     unsigned short lsAge = updatePacket->getAsExternalLSAs (0).getHeader ().getLsAge ();
00459                     if (lsAge < MAX_AGE - interfaceTransmissionDelay) {
00460                         updatePacket->getAsExternalLSAs (0).getHeader ().setLsAge (lsAge + interfaceTransmissionDelay);
00461                     } else {
00462                         updatePacket->getAsExternalLSAs (0).getHeader ().setLsAge (MAX_AGE);
00463                     }
00464                 }
00465                 break;
00466             default: break;
00467         }
00468 
00469         updatePacket->setPacketLength (0); // TODO: Calculate correct length
00470         updatePacket->setChecksum (0); // TODO: Calculate correct cheksum (16-bit one's complement of the entire packet)
00471 
00472         return updatePacket;
00473     }
00474     return NULL;
00475 }

bool OSPF::Interface::FloodLSA (  OSPFLSA *  lsa,
OSPF::Interface *  intf = NULL,
OSPF::Neighbor *  neighbor = NULL
) 
 

See also:
RFC2328 Section 13.3. 
00261 {
00262     bool floodedBackOut = false;
00263 
00264     if (
00265         (
00266          (lsa->getHeader ().getLsType () == ASExternalLSAType) &&
00267          (interfaceType != OSPF::Interface::Virtual) &&
00268          (parentArea->GetExternalRoutingCapability ())
00269         ) ||
00270         (
00271          (lsa->getHeader ().getLsType () != ASExternalLSAType) &&
00272          (
00273           (
00274            (areaID != OSPF::BackboneAreaID) &&
00275            (interfaceType != OSPF::Interface::Virtual)
00276           ) ||
00277           (areaID == OSPF::BackboneAreaID)
00278          )
00279         )
00280        )
00281     {
00282         long              neighborCount                = neighboringRouters.size ();
00283         bool              lsaAddedToRetransmissionList = false;
00284         OSPF::LinkStateID linkStateID                  = lsa->getHeader ().getLinkStateID ();
00285         OSPF::LSAKeyType  lsaKey;
00286 
00287         lsaKey.linkStateID = linkStateID;
00288         lsaKey.advertisingRouter = lsa->getHeader ().getAdvertisingRouter ().getInt ();
00289 
00290         for (long i = 0; i < neighborCount; i++) {  // (1)
00291             if (neighboringRouters[i]->GetState () < OSPF::Neighbor::ExchangeState) {   // (1) (a)
00292                 continue;
00293             }
00294             if (neighboringRouters[i]->GetState () < OSPF::Neighbor::FullState) {   // (1) (b)
00295                 OSPFLSAHeader* requestLSAHeader = neighboringRouters[i]->FindOnRequestList (lsaKey);
00296                 if (requestLSAHeader != NULL) {
00297                     // operator< and operator== on OSPFLSAHeaders determines which one is newer (less means older)
00298                     if (lsa->getHeader () < (*requestLSAHeader)) {
00299                         continue;
00300                     }
00301                     if (operator== (lsa->getHeader (), (*requestLSAHeader))) {
00302                         neighboringRouters[i]->RemoveFromRequestList (lsaKey);
00303                         continue;
00304                     }
00305                     neighboringRouters[i]->RemoveFromRequestList (lsaKey);
00306                 }
00307             }
00308             if (neighbor == neighboringRouters[i]) {     // (1) (c)
00309                 continue;
00310             }
00311             neighboringRouters[i]->AddToRetransmissionList (lsa);   // (1) (d)
00312             lsaAddedToRetransmissionList = true;
00313         }
00314         if (lsaAddedToRetransmissionList) {     // (2)
00315             if ((intf != this) ||
00316                 ((neighbor != NULL) &&
00317                  (neighbor->GetNeighborID () != designatedRouter.routerID) &&
00318                  (neighbor->GetNeighborID () != backupDesignatedRouter.routerID)))  // (3)
00319             {
00320                 if ((intf != this) || (GetState () != OSPF::Interface::BackupState)) {  // (4)
00321                     OSPFLinkStateUpdatePacket* updatePacket = CreateUpdatePacket (lsa);    // (5)
00322 
00323                     if (updatePacket != NULL) {
00324                         int                   ttl            = (interfaceType == OSPF::Interface::Virtual) ? VIRTUAL_LINK_TTL : 1;
00325                         OSPF::MessageHandler* messageHandler = parentArea->GetRouter ()->GetMessageHandler ();
00326 
00327                         if (interfaceType == OSPF::Interface::Broadcast) {
00328                             if ((GetState () == OSPF::Interface::DesignatedRouterState) ||
00329                                 (GetState () == OSPF::Interface::BackupState) ||
00330                                 (designatedRouter == OSPF::NullDesignatedRouterID))
00331                             {
00332                                 messageHandler->SendPacket (updatePacket, OSPF::AllSPFRouters, ifIndex, ttl);
00333                                 for (long k = 0; k < neighborCount; k++) {
00334                                     neighboringRouters[k]->AddToTransmittedLSAList (lsaKey);
00335                                     if (!neighboringRouters[k]->IsUpdateRetransmissionTimerActive ()) {
00336                                         neighboringRouters[k]->StartUpdateRetransmissionTimer ();
00337                                     }
00338                                 }
00339                             } else {
00340                                 messageHandler->SendPacket (updatePacket, OSPF::AllDRouters, ifIndex, ttl);
00341                                 OSPF::Neighbor* dRouter = GetNeighborByID (designatedRouter.routerID);
00342                                 OSPF::Neighbor* backupDRouter = GetNeighborByID (backupDesignatedRouter.routerID);
00343                                 if (dRouter != NULL) {
00344                                     dRouter->AddToTransmittedLSAList (lsaKey);
00345                                     if (!dRouter->IsUpdateRetransmissionTimerActive ()) {
00346                                         dRouter->StartUpdateRetransmissionTimer ();
00347                                     }
00348                                 }
00349                                 if (backupDRouter != NULL) {
00350                                     backupDRouter->AddToTransmittedLSAList (lsaKey);
00351                                     if (!backupDRouter->IsUpdateRetransmissionTimerActive ()) {
00352                                         backupDRouter->StartUpdateRetransmissionTimer ();
00353                                     }
00354                                 }
00355                             }
00356                         } else {
00357                             if (interfaceType == OSPF::Interface::PointToPoint) {
00358                                 messageHandler->SendPacket (updatePacket, OSPF::AllSPFRouters, ifIndex, ttl);
00359                                 if (neighborCount > 0) {
00360                                     neighboringRouters[0]->AddToTransmittedLSAList (lsaKey);
00361                                     if (!neighboringRouters[0]->IsUpdateRetransmissionTimerActive ()) {
00362                                         neighboringRouters[0]->StartUpdateRetransmissionTimer ();
00363                                     }
00364                                 }
00365                             } else {
00366                                 for (long m = 0; m < neighborCount; m++) {
00367                                     if (neighboringRouters[m]->GetState () >= OSPF::Neighbor::ExchangeState) {
00368                                         messageHandler->SendPacket (updatePacket, neighboringRouters[m]->GetAddress (), ifIndex, ttl);
00369                                         neighboringRouters[m]->AddToTransmittedLSAList (lsaKey);
00370                                         if (!neighboringRouters[m]->IsUpdateRetransmissionTimerActive ()) {
00371                                             neighboringRouters[m]->StartUpdateRetransmissionTimer ();
00372                                         }
00373                                     }
00374                                 }
00375                             }
00376                         }
00377 
00378                         if (intf == this) {
00379                             floodedBackOut = true;
00380                         }
00381                     }
00382                 }
00383             }
00384         }
00385     }
00386 
00387     return floodedBackOut;
00388 }

short OSPF::Interface::GetAcknowledgementDelay (  void   )  const [inline]
  

00120 { return acknowledgementDelay; }

OSPFTimer* OSPF::Interface::GetAcknowledgementTimer (  void   )  [inline]
  

00138 { return acknowledgementTimer; }

IPv4AddressRange OSPF::Interface::GetAddressRange (  void   )  const [inline]
  

00134 { return interfaceAddressRange; }

const Area* OSPF::Interface::GetArea (  void   )  const [inline]
  

00147 { return parentArea; }

Area* OSPF::Interface::GetArea (  void   )  [inline]
  

00146 { return parentArea; }

AreaID OSPF::Interface::GetAreaID (  void   )  const [inline]
  

00112 { return areaID; }

AuthenticationKeyType OSPF::Interface::GetAuthenticationKey (  void   )  const [inline]
  

00132 { return authenticationKey; }

AuthenticationType OSPF::Interface::GetAuthenticationType (  void   )  const [inline]
  

00130 { return authenticationType; }

DesignatedRouterID OSPF::Interface::GetBackupDesignatedRouter (  void   )  const [inline]
  

00140 { return backupDesignatedRouter; }

DesignatedRouterID OSPF::Interface::GetDesignatedRouter (  void   )  const [inline]
  

00139 { return designatedRouter; }

short OSPF::Interface::GetHelloInterval (  void   )  const [inline]
  

00124 { return helloInterval; }

OSPFTimer* OSPF::Interface::GetHelloTimer (  void   )  [inline]
  

00136 { return helloTimer; }

unsigned char OSPF::Interface::GetIfIndex (  void   )  const [inline]
  

00108 { return ifIndex; }

unsigned short OSPF::Interface::GetMTU (  void   )  const [inline]
  

00110 { return mtu; }

const Neighbor* OSPF::Interface::GetNeighbor (  unsigned long  i  )  const [inline]
  

00143 { return neighboringRouters[i]; }

Neighbor* OSPF::Interface::GetNeighbor (  unsigned long  i  )  [inline]
  

00142 { return neighboringRouters[i]; }

OSPF::Neighbor * OSPF::Interface::GetNeighborByAddress (  IPv4Address  address  ) 
  

00188 {
00189     std::map<OSPF::IPv4Address, OSPF::Neighbor*, OSPF::IPv4Address_Less>::iterator neighborIt = neighboringRoutersByAddress.find (address);
00190     if (neighborIt != neighboringRoutersByAddress.end ()) {
00191         return (neighborIt->second);
00192     }
00193     else {
00194         return NULL;
00195     }
00196 }

OSPF::Neighbor * OSPF::Interface::GetNeighborByID (  RouterID  neighborID  ) 
  

00177 {
00178     std::map<OSPF::RouterID, OSPF::Neighbor*>::iterator neighborIt = neighboringRoutersByID.find (neighborID);
00179     if (neighborIt != neighboringRoutersByID.end ()) {
00180         return (neighborIt->second);
00181     }
00182     else {
00183         return NULL;
00184     }
00185 }

unsigned long OSPF::Interface::GetNeighborCount (  void   )  const [inline]
  

00141 { return neighboringRouters.size (); }

Metric OSPF::Interface::GetOutputCost (  void   )  const [inline]
  

00114 { return interfaceOutputCost; }

short OSPF::Interface::GetPollInterval (  void   )  const [inline]
  

00126 { return pollInterval; }

short OSPF::Interface::GetRetransmissionInterval (  void   )  const [inline]
  

00116 { return retransmissionInterval; }

short OSPF::Interface::GetRouterDeadInterval (  void   )  const [inline]
  

00128 { return routerDeadInterval; }

unsigned char OSPF::Interface::GetRouterPriority (  void   )  const [inline]
  

00122 { return routerPriority; }

OSPF::Interface::InterfaceStateType OSPF::Interface::GetState (  void   )  const
  

00207 {
00208     return state->GetState ();
00209 }

const char * OSPF::Interface::GetStateString (  InterfaceStateType  stateType  )  [static]
  

00212 {
00213     switch (stateType) {
00214         case DownState:                 return "Down";
00215         case LoopbackState:             return "Loopback";
00216         case WaitingState:              return "Waiting";
00217         case PointToPointState:         return "PointToPoint";
00218         case NotDesignatedRouterState:  return "NotDesignatedRouter";
00219         case BackupState:               return "Backup";
00220         case DesignatedRouterState:     return "DesignatedRouter";
00221         default:                        ASSERT (false);
00222     }
00223     return "";
00224 }

short OSPF::Interface::GetTransmissionDelay (  void   )  const [inline]
  

00118 { return interfaceTransmissionDelay; }

OSPFInterfaceType OSPF::Interface::GetType (  void   )  const [inline]
  

00106 { return interfaceType; }

OSPFTimer* OSPF::Interface::GetWaitTimer (  void   )  [inline]
  

00137 { return waitTimer; }

bool OSPF::Interface::IsOnAnyRetransmissionList (  LSAKeyType  lsaKey  )  const
  

00247 {
00248     long neighborCount = neighboringRouters.size ();
00249     for (long i = 0; i < neighborCount; i++) {
00250         if (neighboringRouters[i]->IsLSAOnRetransmissionList (lsaKey)) {
00251             return true;
00252         }
00253     }
00254     return false;
00255 }

void OSPF::Interface::ProcessEvent (  InterfaceEventType  event  ) 
  

00087 {
00088     state->ProcessEvent (this, event);
00089 }

void OSPF::Interface::RemoveFromAllRetransmissionLists (  LSAKeyType  lsaKey  ) 
  

00239 {
00240     long neighborCount = neighboringRouters.size ();
00241     for (long i = 0; i < neighborCount; i++) {
00242         neighboringRouters[i]->RemoveFromRetransmissionList (lsaKey);
00243     }
00244 }

void OSPF::Interface::Reset (  void   ) 
  

00092 {
00093     MessageHandler* messageHandler = parentArea->GetRouter ()->GetMessageHandler ();
00094     messageHandler->ClearTimer (helloTimer);
00095     messageHandler->ClearTimer (waitTimer);
00096     messageHandler->ClearTimer (acknowledgementTimer);
00097     designatedRouter = NullDesignatedRouterID;
00098     backupDesignatedRouter = NullDesignatedRouterID;
00099     long neighborCount = neighboringRouters.size ();
00100     for (long i = 0; i < neighborCount; i++) {
00101         neighboringRouters[i]->ProcessEvent (OSPF::Neighbor::KillNeighbor);
00102     }
00103 }

void OSPF::Interface::SendDelayedAcknowledgements (  void   ) 
  

00499 {
00500     OSPF::MessageHandler* messageHandler = parentArea->GetRouter ()->GetMessageHandler ();
00501     long                  maxPacketSize  = ((IPV4_HEADER_LENGTH + OSPF_HEADER_LENGTH + OSPF_LSA_HEADER_LENGTH) > mtu) ? IPV4_DATAGRAM_LENGTH : mtu;
00502 
00503     for (std::map<IPv4Address, std::list<OSPFLSAHeader>, OSPF::IPv4Address_Less>::iterator delayIt = delayedAcknowledgements.begin ();
00504          delayIt != delayedAcknowledgements.end ();
00505          delayIt++)
00506     {
00507         int ackCount = delayIt->second.size ();
00508         if (ackCount > 0) {
00509             while (!(delayIt->second.empty ())) {
00510                 OSPFLinkStateAcknowledgementPacket* ackPacket  = new OSPFLinkStateAcknowledgementPacket;
00511                 long                                packetSize = IPV4_HEADER_LENGTH + OSPF_HEADER_LENGTH;
00512 
00513                 ackPacket->setType (LinkStateAcknowledgementPacket);
00514                 ackPacket->setRouterID (parentArea->GetRouter ()->GetRouterID ());
00515                 ackPacket->setAreaID (areaID);
00516                 ackPacket->setAuthenticationType (authenticationType);
00517                 for (int i = 0; i < 8; i++) {
00518                     ackPacket->setAuthentication (i, authenticationKey.bytes[i]);
00519                 }
00520 
00521                 while ((!(delayIt->second.empty ())) && (packetSize <= (maxPacketSize - OSPF_LSA_HEADER_LENGTH))) {
00522                     unsigned long   headerCount = ackPacket->getLsaHeadersArraySize ();
00523                     ackPacket->setLsaHeadersArraySize (headerCount + 1);
00524                     ackPacket->setLsaHeaders (headerCount, *(delayIt->second.begin ()));
00525                     delayIt->second.pop_front ();
00526                     packetSize += OSPF_LSA_HEADER_LENGTH;
00527                 }
00528 
00529                 ackPacket->setPacketLength (0); // TODO: Calculate correct length
00530                 ackPacket->setChecksum (0); // TODO: Calculate correct cheksum (16-bit one's complement of the entire packet)
00531 
00532                 int ttl = (interfaceType == OSPF::Interface::Virtual) ? VIRTUAL_LINK_TTL : 1;
00533 
00534                 if (interfaceType == OSPF::Interface::Broadcast) {
00535                     if ((GetState () == OSPF::Interface::DesignatedRouterState) ||
00536                         (GetState () == OSPF::Interface::BackupState) ||
00537                         (designatedRouter == OSPF::NullDesignatedRouterID))
00538                     {
00539                         messageHandler->SendPacket (ackPacket, OSPF::AllSPFRouters, ifIndex, ttl);
00540                     } else {
00541                         messageHandler->SendPacket (ackPacket, OSPF::AllDRouters, ifIndex, ttl);
00542                     }
00543                 } else {
00544                     if (interfaceType == OSPF::Interface::PointToPoint) {
00545                         messageHandler->SendPacket (ackPacket, OSPF::AllSPFRouters, ifIndex, ttl);
00546                     } else {
00547                         messageHandler->SendPacket (ackPacket, delayIt->first, ifIndex, ttl);
00548                     }
00549                 }
00550             }
00551         }
00552     }
00553     messageHandler->StartTimer (acknowledgementTimer, acknowledgementDelay);
00554 }

void OSPF::Interface::SendHelloPacket (  IPv4Address  destination,
short  ttl = 1
) 
  

00106 {
00107     OSPFOptions options;
00108     OSPFHelloPacket* helloPacket = new OSPFHelloPacket;
00109     std::vector<OSPF::IPv4Address> neighbors;
00110 
00111     helloPacket->setRouterID (parentArea->GetRouter ()->GetRouterID ());
00112     helloPacket->setAreaID (parentArea->GetAreaID ());
00113     helloPacket->setAuthenticationType (authenticationType);
00114     for (int i = 0; i < 8; i++) {
00115         helloPacket->setAuthentication (i, authenticationKey.bytes[i]);
00116     }
00117 
00118     if (((interfaceType == PointToPoint) &&
00119          (interfaceAddressRange.address == OSPF::NullIPv4Address)) ||
00120         (interfaceType == Virtual))
00121     {
00122         helloPacket->setNetworkMask (ULongFromIPv4Address (OSPF::NullIPv4Address));
00123     } else {
00124         helloPacket->setNetworkMask (ULongFromIPv4Address (interfaceAddressRange.mask));
00125     }
00126     memset (&options, 0, sizeof (OSPFOptions));
00127     options.E_ExternalRoutingCapability = parentArea->GetExternalRoutingCapability ();
00128     helloPacket->setOptions (options);
00129     helloPacket->setHelloInterval (helloInterval);
00130     helloPacket->setRouterPriority (routerPriority);
00131     helloPacket->setRouterDeadInterval (routerDeadInterval);
00132     helloPacket->setDesignatedRouter (ULongFromIPv4Address (designatedRouter.ipInterfaceAddress));
00133     helloPacket->setBackupDesignatedRouter (ULongFromIPv4Address (backupDesignatedRouter.ipInterfaceAddress));
00134     long neighborCount = neighboringRouters.size ();
00135     for (long j = 0; j < neighborCount; j++) {
00136         if (neighboringRouters[j]->GetState () >= OSPF::Neighbor::InitState) {
00137             neighbors.push_back (neighboringRouters[j]->GetAddress ());
00138         }
00139     }
00140     unsigned int initedNeighborCount = neighbors.size ();
00141     helloPacket->setNeighborArraySize (initedNeighborCount);
00142     for (unsigned int k = 0; k < initedNeighborCount; k++) {
00143         helloPacket->setNeighbor (k, ULongFromIPv4Address (neighbors[k]));
00144     }
00145 
00146     helloPacket->setPacketLength (0); // TODO: Calculate correct length
00147     helloPacket->setChecksum (0); // TODO: Calculate correct cheksum (16-bit one's complement of the entire packet)
00148 
00149     parentArea->GetRouter ()->GetMessageHandler ()->SendPacket (helloPacket, destination, ifIndex, ttl);
00150 }

void OSPF::Interface::SendLSAcknowledgement (  OSPFLSAHeader *  lsaHeader,
IPv4Address  destination
) 
  

00153 {
00154     OSPFOptions                         options;
00155     OSPFLinkStateAcknowledgementPacket* lsAckPacket = new OSPFLinkStateAcknowledgementPacket;
00156 
00157     lsAckPacket->setType (LinkStateAcknowledgementPacket);
00158     lsAckPacket->setRouterID (parentArea->GetRouter ()->GetRouterID ());
00159     lsAckPacket->setAreaID (parentArea->GetAreaID ());
00160     lsAckPacket->setAuthenticationType (authenticationType);
00161     for (int i = 0; i < 8; i++) {
00162         lsAckPacket->setAuthentication (i, authenticationKey.bytes[i]);
00163     }
00164 
00165     lsAckPacket->setLsaHeadersArraySize (1);
00166     lsAckPacket->setLsaHeaders (0, *lsaHeader);
00167 
00168     lsAckPacket->setPacketLength (0); // TODO: Calculate correct length
00169     lsAckPacket->setChecksum (0); // TODO: Calculate correct cheksum (16-bit one's complement of the entire packet)
00170 
00171     int ttl = (interfaceType == OSPF::Interface::Virtual) ? VIRTUAL_LINK_TTL : 1;
00172     parentArea->GetRouter ()->GetMessageHandler ()->SendPacket (lsAckPacket, destination, ifIndex, ttl);
00173 }

void OSPF::Interface::SetAcknowledgementDelay (  short  delay  )  [inline]
  

00119 { acknowledgementDelay = delay; }

void OSPF::Interface::SetAddressRange (  IPv4AddressRange  range  )  [inline]
  

00133 { interfaceAddressRange = range; }

void OSPF::Interface::SetArea (  Area *  area  )  [inline]
  

00145 { parentArea = area; }

void OSPF::Interface::SetAreaID (  AreaID  areaId  )  [inline]
  

00111 { areaID = areaId; }

void OSPF::Interface::SetAuthenticationKey (  AuthenticationKeyType  key  )  [inline]
  

00131 { authenticationKey = key; }

void OSPF::Interface::SetAuthenticationType (  AuthenticationType  type  )  [inline]
  

00129 { authenticationType = type; }

void OSPF::Interface::SetHelloInterval (  short  interval  )  [inline]
  

00123 { helloInterval = interval; }

void OSPF::Interface::SetIfIndex (  unsigned char  index  ) 
  

00067 {
00068     ifIndex = index;
00069     if (interfaceType == OSPF::Interface::UnknownType) {
00070         InterfaceEntry* routingInterface = InterfaceTableAccess().get ()->interfaceAt (ifIndex);
00071         interfaceAddressRange.address = IPv4AddressFromAddressString (routingInterface->ipv4()->inetAddress ().str ().c_str ());
00072         interfaceAddressRange.mask = IPv4AddressFromAddressString (routingInterface->ipv4()->netmask ().str ().c_str ());
00073         mtu = routingInterface->mtu ();
00074     }
00075 }

void OSPF::Interface::SetMTU (  unsigned short  ifMTU  )  [inline]
  

00109 { mtu = ifMTU; }

void OSPF::Interface::SetOutputCost (  Metric  cost  )  [inline]
  

00113 { interfaceOutputCost = cost; }

void OSPF::Interface::SetPollInterval (  short  interval  )  [inline]
  

00125 { pollInterval = interval; }

void OSPF::Interface::SetRetransmissionInterval (  short  interval  )  [inline]
  

00115 { retransmissionInterval = interval; }

void OSPF::Interface::SetRouterDeadInterval (  short  interval  )  [inline]
  

00127 { routerDeadInterval = interval; }

void OSPF::Interface::SetRouterPriority (  unsigned char  priority  )  [inline]
  

00121 { routerPriority = priority; }

void OSPF::Interface::SetTransmissionDelay (  short  delay  )  [inline]
  

00117 { interfaceTransmissionDelay = delay; }

void OSPF::Interface::SetType (  OSPFInterfaceType  ifType  )  [inline]
  

00105 { interfaceType = ifType; }

Friends And Related Function Documentation

friend class InterfaceState [friend]
 

Member Data Documentation

short OSPF::Interface::acknowledgementDelay [private]
 

OSPFTimer* OSPF::Interface::acknowledgementTimer [private]
 

AreaID OSPF::Interface::areaID [private]
 

AuthenticationKeyType OSPF::Interface::authenticationKey [private]
 

AuthenticationType OSPF::Interface::authenticationType [private]
 

DesignatedRouterID OSPF::Interface::backupDesignatedRouter [private]
 

std::map<IPv4Address, std::list<OSPFLSAHeader>, IPv4Address_Less> OSPF::Interface::delayedAcknowledgements [private]
 

DesignatedRouterID OSPF::Interface::designatedRouter [private]
 

short OSPF::Interface::helloInterval [private]
 

OSPFTimer* OSPF::Interface::helloTimer [private]
 

unsigned char OSPF::Interface::ifIndex [private]
 

IPv4AddressRange OSPF::Interface::interfaceAddressRange [private]
 

Metric OSPF::Interface::interfaceOutputCost [private]
 

short OSPF::Interface::interfaceTransmissionDelay [private]
 

OSPFInterfaceType OSPF::Interface::interfaceType [private]
 

unsigned short OSPF::Interface::mtu [private]
 

std::vector<Neighbor*> OSPF::Interface::neighboringRouters [private]
 

std::map<IPv4Address, Neighbor*, IPv4Address_Less> OSPF::Interface::neighboringRoutersByAddress [private]
 

std::map<RouterID, Neighbor*> OSPF::Interface::neighboringRoutersByID [private]
 

Area* OSPF::Interface::parentArea [private]
 

short OSPF::Interface::pollInterval [private]
 

InterfaceState* OSPF::Interface::previousState [private]
 

short OSPF::Interface::retransmissionInterval [private]
 

short OSPF::Interface::routerDeadInterval [private]
 

unsigned char OSPF::Interface::routerPriority [private]
 

InterfaceState* OSPF::Interface::state [private]
 

OSPFTimer* OSPF::Interface::waitTimer [private]
 

The documentation for this class was generated from the following files:
Generated on Sat Apr 1 20:52:25 2006 for INET Framework for OMNeT++/OMNEST by  doxygen 1.4.1