OSPF::Interface Class Reference

#include <OSPFInterface.h>

List of all members.

Public Types

 InterfaceUp = 0
 HelloTimer = 1
 WaitTimer = 2
 AcknowledgementTimer = 3
 BackupSeen = 4
 NeighborChange = 5
 LoopIndication = 6
 UnloopIndication = 7
 InterfaceDown = 8
 UnknownType = 0
 PointToPoint = 1
 Broadcast = 2
 NBMA = 3
 PointToMultiPoint = 4
 Virtual = 5
 DownState = 0
 LoopbackState = 1
 WaitingState = 2
 PointToPointState = 3
 NotDesignatedRouterState = 4
 BackupState = 5
 DesignatedRouterState = 6
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)
NeighborGetNeighborByID (RouterID neighborID)
NeighborGetNeighborByAddress (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)
OSPFLinkStateUpdatePacketCreateUpdatePacket (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 SetTransitAreaID (AreaID areaId)
AreaID GetTransitAreaID (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
OSPFTimerGetHelloTimer (void)
OSPFTimerGetWaitTimer (void)
OSPFTimerGetAcknowledgementTimer (void)
DesignatedRouterID GetDesignatedRouter (void) const
DesignatedRouterID GetBackupDesignatedRouter (void) const
unsigned long GetNeighborCount (void) const
NeighborGetNeighbor (unsigned long i)
const NeighborGetNeighbor (unsigned long i) const
void SetArea (Area *area)
AreaGetArea (void)
const AreaGetArea (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
InterfaceStatestate
InterfaceStatepreviousState
unsigned char ifIndex
unsigned short mtu
IPv4AddressRange interfaceAddressRange
AreaID areaID
AreaID transitAreaID
short helloInterval
short pollInterval
short routerDeadInterval
short interfaceTransmissionDelay
unsigned char routerPriority
OSPFTimerhelloTimer
OSPFTimerwaitTimer
OSPFTimeracknowledgementTimer
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
AreaparentArea

Friends

class InterfaceState


Member Enumeration Documentation

enum OSPF::Interface::InterfaceEventType

Enumerator:
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

Enumerator:
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

Enumerator:
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     transitAreaID (OSPF::BackboneAreaID),
00018     helloInterval (10),
00019     pollInterval (120),
00020     routerDeadInterval (40),
00021     interfaceTransmissionDelay (1),
00022     routerPriority (0),
00023     designatedRouter (OSPF::NullDesignatedRouterID),
00024     backupDesignatedRouter (OSPF::NullDesignatedRouterID),
00025     interfaceOutputCost (1),
00026     retransmissionInterval (5),
00027     acknowledgementDelay (1),
00028     authenticationType (OSPF::NullType),
00029     parentArea (NULL)
00030 {
00031     state = new OSPF::InterfaceStateDown;
00032     previousState = NULL;
00033     helloTimer = new OSPFTimer;
00034     helloTimer->setTimerKind (InterfaceHelloTimer);
00035     helloTimer->setContextPointer (this);
00036     helloTimer->setName ("OSPF::Interface::InterfaceHelloTimer");
00037     waitTimer = new OSPFTimer;
00038     waitTimer->setTimerKind (InterfaceWaitTimer);
00039     waitTimer->setContextPointer (this);
00040     waitTimer->setName ("OSPF::Interface::InterfaceWaitTimer");
00041     acknowledgementTimer = new OSPFTimer;
00042     acknowledgementTimer->setTimerKind (InterfaceAcknowledgementTimer);
00043     acknowledgementTimer->setContextPointer (this);
00044     acknowledgementTimer->setName ("OSPF::Interface::InterfaceAcknowledgementTimer");
00045     memset (authenticationKey.bytes, 0, 8 * sizeof (char));
00046 }

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

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


Member Function Documentation

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

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

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

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

void OSPF::Interface::AgeTransmittedLSALists ( void   ) 

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

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

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

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

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

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

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

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

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

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

00123 { return acknowledgementDelay; }

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

00141 { return acknowledgementTimer; }

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

00137 { return interfaceAddressRange; }

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

00150 { return parentArea; }

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

00149 { return parentArea; }

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

00113 { return areaID; }

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

00135 { return authenticationKey; }

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

00133 { return authenticationType; }

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

00143 { return backupDesignatedRouter; }

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

00142 { return designatedRouter; }

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

00127 { return helloInterval; }

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

00139 { return helloTimer; }

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

00109 { return ifIndex; }

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

00111 { return mtu; }

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

00146 { return neighboringRouters[i]; }

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

00145 { return neighboringRouters[i]; }

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

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

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

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

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

00144 { return neighboringRouters.size (); }

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

00117 { return interfaceOutputCost; }

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

00129 { return pollInterval; }

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

00119 { return retransmissionInterval; }

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

00131 { return routerDeadInterval; }

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

00125 { return routerPriority; }

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

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

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

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

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

00115 { return transitAreaID; }

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

00121 { return interfaceTransmissionDelay; }

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

00107 { return interfaceType; }

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

00140 { return waitTimer; }

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

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

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

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

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

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

void OSPF::Interface::Reset ( void   ) 

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

void OSPF::Interface::SendDelayedAcknowledgements ( void   ) 

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

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

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

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

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

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

00122 { acknowledgementDelay = delay; }

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

00136 { interfaceAddressRange = range; }

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

00148 { parentArea = area; }

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

00112 { areaID = areaId; }

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

00134 { authenticationKey = key; }

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

00132 { authenticationType = type; }

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

00126 { helloInterval = interval; }

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

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

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

00110 { mtu = ifMTU; }

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

00116 { interfaceOutputCost = cost; }

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

00128 { pollInterval = interval; }

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

00118 { retransmissionInterval = interval; }

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

00130 { routerDeadInterval = interval; }

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

00124 { routerPriority = priority; }

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

00114 { transitAreaID = areaId; }

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

00120 { interfaceTransmissionDelay = delay; }

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

00106 { 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]

AreaID OSPF::Interface::transitAreaID [private]

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


The documentation for this class was generated from the following files:
Generated on Wed Apr 4 13:20:25 2007 for INET Framework for OMNeT++/OMNEST by  doxygen 1.4.7