OSPF::InterfaceState Class Reference

#include <OSPFInterfaceState.h>

Inheritance diagram for OSPF::InterfaceState:

OSPF::InterfaceStateBackup OSPF::InterfaceStateDesignatedRouter OSPF::InterfaceStateDown OSPF::InterfaceStateLoopback OSPF::InterfaceStateNotDesignatedRouter OSPF::InterfaceStatePointToPoint OSPF::InterfaceStateWaiting

List of all members.

Public Member Functions

virtual ~InterfaceState ()
virtual void ProcessEvent (Interface *intf, Interface::InterfaceEventType event)=0
virtual
Interface::InterfaceStateType 
GetState (void) const =0

Protected Member Functions

void ChangeState (Interface *intf, InterfaceState *newState, InterfaceState *currentState)
void CalculateDesignatedRouter (Interface *intf)


Constructor & Destructor Documentation

virtual OSPF::InterfaceState::~InterfaceState (  )  [inline, virtual]

00031 {}


Member Function Documentation

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

Referenced by CalculateDesignatedRouter(), OSPF::InterfaceStateWaiting::ProcessEvent(), OSPF::InterfaceStatePointToPoint::ProcessEvent(), OSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), OSPF::InterfaceStateLoopback::ProcessEvent(), OSPF::InterfaceStateDown::ProcessEvent(), OSPF::InterfaceStateDesignatedRouter::ProcessEvent(), and OSPF::InterfaceStateBackup::ProcessEvent().

00028 {
00029     OSPF::Interface::InterfaceStateType oldState            = currentState->GetState();
00030     OSPF::Interface::InterfaceStateType nextState           = newState->GetState();
00031     OSPF::Interface::OSPFInterfaceType  intfType            = intf->GetType();
00032     bool                                rebuildRoutingTable = false;
00033 
00034     intf->ChangeState(newState, currentState);
00035 
00036     if ((oldState == OSPF::Interface::DownState) ||
00037         (nextState == OSPF::Interface::DownState) ||
00038         (oldState == OSPF::Interface::LoopbackState) ||
00039         (nextState == OSPF::Interface::LoopbackState) ||
00040         (oldState == OSPF::Interface::DesignatedRouterState) ||
00041         (nextState == OSPF::Interface::DesignatedRouterState) ||
00042         ((intfType == OSPF::Interface::PointToPoint) &&
00043          ((oldState == OSPF::Interface::PointToPointState) ||
00044           (nextState == OSPF::Interface::PointToPointState))) ||
00045         (((intfType == OSPF::Interface::Broadcast) ||
00046           (intfType == OSPF::Interface::NBMA)) &&
00047          ((oldState == OSPF::Interface::WaitingState) ||
00048           (nextState == OSPF::Interface::WaitingState))))
00049     {
00050         OSPF::RouterLSA* routerLSA = intf->GetArea()->FindRouterLSA(intf->GetArea()->GetRouter()->GetRouterID());
00051 
00052         if (routerLSA != NULL) {
00053             long sequenceNumber = routerLSA->getHeader().getLsSequenceNumber();
00054             if (sequenceNumber == MAX_SEQUENCE_NUMBER) {
00055                 routerLSA->getHeader().setLsAge(MAX_AGE);
00056                 intf->GetArea()->FloodLSA(routerLSA);
00057                 routerLSA->IncrementInstallTime();
00058             } else {
00059                 OSPF::RouterLSA* newLSA = intf->GetArea()->OriginateRouterLSA();
00060 
00061                 newLSA->getHeader().setLsSequenceNumber(sequenceNumber + 1);
00062                 newLSA->getHeader().setLsChecksum(0);    // TODO: calculate correct LS checksum
00063                 rebuildRoutingTable |= routerLSA->Update(newLSA);
00064                 delete newLSA;
00065 
00066                 intf->GetArea()->FloodLSA(routerLSA);
00067             }
00068         } else {  // (lsa == NULL) -> This must be the first time any interface is up...
00069             OSPF::RouterLSA* newLSA = intf->GetArea()->OriginateRouterLSA();
00070 
00071             rebuildRoutingTable |= intf->GetArea()->InstallRouterLSA(newLSA);
00072 
00073             routerLSA = intf->GetArea()->FindRouterLSA(intf->GetArea()->GetRouter()->GetRouterID());
00074 
00075             intf->GetArea()->SetSPFTreeRoot(routerLSA);
00076             intf->GetArea()->FloodLSA(newLSA);
00077             delete newLSA;
00078         }
00079     }
00080 
00081     if (nextState == OSPF::Interface::DesignatedRouterState) {
00082         OSPF::NetworkLSA* newLSA = intf->GetArea()->OriginateNetworkLSA(intf);
00083         if (newLSA != NULL) {
00084             rebuildRoutingTable |= intf->GetArea()->InstallNetworkLSA(newLSA);
00085 
00086             intf->GetArea()->FloodLSA(newLSA);
00087             delete newLSA;
00088         } else {    // no neighbors on the network -> old NetworkLSA must be flushed
00089             OSPF::NetworkLSA* oldLSA = intf->GetArea()->FindNetworkLSA(ULongFromIPv4Address(intf->GetAddressRange().address));
00090 
00091             if (oldLSA != NULL) {
00092                 oldLSA->getHeader().setLsAge(MAX_AGE);
00093                 intf->GetArea()->FloodLSA(oldLSA);
00094                 oldLSA->IncrementInstallTime();
00095             }
00096         }
00097     }
00098 
00099     if (oldState == OSPF::Interface::DesignatedRouterState) {
00100         OSPF::NetworkLSA* networkLSA = intf->GetArea()->FindNetworkLSA(ULongFromIPv4Address(intf->GetAddressRange().address));
00101 
00102         if (networkLSA != NULL) {
00103             networkLSA->getHeader().setLsAge(MAX_AGE);
00104             intf->GetArea()->FloodLSA(networkLSA);
00105             networkLSA->IncrementInstallTime();
00106         }
00107     }
00108 
00109     if (rebuildRoutingTable) {
00110         intf->GetArea()->GetRouter()->RebuildRoutingTable();
00111     }
00112 }

void OSPF::InterfaceState::CalculateDesignatedRouter ( OSPF::Interface intf  )  [protected]

Referenced by OSPF::InterfaceStateWaiting::ProcessEvent(), OSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), OSPF::InterfaceStateDesignatedRouter::ProcessEvent(), and OSPF::InterfaceStateBackup::ProcessEvent().

00115 {
00116     OSPF::RouterID           routerID                = intf->parentArea->GetRouter()->GetRouterID();
00117     OSPF::DesignatedRouterID currentDesignatedRouter = intf->designatedRouter;
00118     OSPF::DesignatedRouterID currentBackupRouter     = intf->backupDesignatedRouter;
00119 
00120     unsigned int             neighborCount           = intf->neighboringRouters.size();
00121     unsigned char            repeatCount             = 0;
00122     unsigned int             i;
00123 
00124     OSPF::DesignatedRouterID declaredBackup;
00125     unsigned char            declaredBackupPriority;
00126     OSPF::RouterID           declaredBackupID;
00127     bool                     backupDeclared;
00128 
00129     OSPF::DesignatedRouterID declaredDesignatedRouter;
00130     unsigned char            declaredDesignatedRouterPriority;
00131     OSPF::RouterID           declaredDesignatedRouterID;
00132     bool                     designatedRouterDeclared;
00133 
00134     do {
00135         // calculating backup designated router
00136         declaredBackup = OSPF::NullDesignatedRouterID;
00137         declaredBackupPriority = 0;
00138         declaredBackupID = OSPF::NullRouterID;
00139         backupDeclared = false;
00140 
00141         OSPF::DesignatedRouterID highestRouter                 = OSPF::NullDesignatedRouterID;
00142         unsigned char            highestPriority               = 0;
00143         OSPF::RouterID           highestID                     = OSPF::NullRouterID;
00144 
00145         for (i = 0; i < neighborCount; i++) {
00146             OSPF::Neighbor* neighbor         = intf->neighboringRouters[i];
00147             unsigned char   neighborPriority = neighbor->GetPriority();
00148 
00149             if (neighbor->GetState() < OSPF::Neighbor::TwoWayState) {
00150                 continue;
00151             }
00152             if (neighborPriority == 0) {
00153                 continue;
00154             }
00155 
00156             OSPF::RouterID           neighborID                      = neighbor->GetNeighborID();
00157             OSPF::DesignatedRouterID neighborsDesignatedRouter       = neighbor->GetDesignatedRouter();
00158             OSPF::DesignatedRouterID neighborsBackupDesignatedRouter = neighbor->GetBackupDesignatedRouter();
00159 
00160             if (neighborsDesignatedRouter.routerID != neighborID) {
00161                 if (neighborsBackupDesignatedRouter.routerID == neighborID) {
00162                     if ((neighborPriority > declaredBackupPriority) ||
00163                         ((neighborPriority == declaredBackupPriority) &&
00164                          (neighborID > declaredBackupID)))
00165                     {
00166                         declaredBackup = neighborsBackupDesignatedRouter;
00167                         declaredBackupPriority = neighborPriority;
00168                         declaredBackupID = neighborID;
00169                         backupDeclared = true;
00170                     }
00171                 }
00172                 if (!backupDeclared) {
00173                     if ((neighborPriority > highestPriority) ||
00174                         ((neighborPriority == highestPriority) &&
00175                          (neighborID > highestID)))
00176                     {
00177                         highestRouter.routerID = neighborID;
00178                         highestRouter.ipInterfaceAddress = neighbor->GetAddress();
00179                         highestPriority = neighborPriority;
00180                         highestID = neighborID;
00181                     }
00182                 }
00183             }
00184         }
00185         // also include the router itself in the calculations
00186         if (intf->routerPriority > 0) {
00187             if (currentDesignatedRouter.routerID != routerID) {
00188                 if (currentBackupRouter.routerID == routerID) {
00189                     if ((intf->routerPriority > declaredBackupPriority) ||
00190                         ((intf->routerPriority == declaredBackupPriority) &&
00191                          (routerID > declaredBackupID)))
00192                     {
00193                         declaredBackup.routerID = routerID;
00194                         declaredBackup.ipInterfaceAddress = intf->interfaceAddressRange.address;
00195                         declaredBackupPriority = intf->routerPriority;
00196                         declaredBackupID = routerID;
00197                         backupDeclared = true;
00198                     }
00199 
00200                 }
00201                 if (!backupDeclared) {
00202                     if ((intf->routerPriority > highestPriority) ||
00203                         ((intf->routerPriority == highestPriority) &&
00204                          (routerID > highestID)))
00205                     {
00206                         declaredBackup.routerID = routerID;
00207                         declaredBackup.ipInterfaceAddress = intf->interfaceAddressRange.address;
00208                         declaredBackupPriority = intf->routerPriority;
00209                         declaredBackupID = routerID;
00210                         backupDeclared = true;
00211                     } else {
00212                         declaredBackup = highestRouter;
00213                         declaredBackupPriority = highestPriority;
00214                         declaredBackupID = highestID;
00215                         backupDeclared = true;
00216                     }
00217                 }
00218             }
00219         }
00220 
00221         // calculating backup designated router
00222         declaredDesignatedRouter = OSPF::NullDesignatedRouterID;
00223         declaredDesignatedRouterPriority = 0;
00224         declaredDesignatedRouterID = OSPF::NullRouterID;
00225         designatedRouterDeclared = false;
00226 
00227         for (i = 0; i < neighborCount; i++) {
00228             OSPF::Neighbor* neighbor         = intf->neighboringRouters[i];
00229             unsigned char   neighborPriority = neighbor->GetPriority();
00230 
00231             if (neighbor->GetState() < OSPF::Neighbor::TwoWayState) {
00232                 continue;
00233             }
00234             if (neighborPriority == 0) {
00235                 continue;
00236             }
00237 
00238             OSPF::RouterID           neighborID                      = neighbor->GetNeighborID();
00239             OSPF::DesignatedRouterID neighborsDesignatedRouter       = neighbor->GetDesignatedRouter();
00240             OSPF::DesignatedRouterID neighborsBackupDesignatedRouter = neighbor->GetBackupDesignatedRouter();
00241 
00242             if (neighborsDesignatedRouter.routerID == neighborID) {
00243                 if ((neighborPriority > declaredDesignatedRouterPriority) ||
00244                     ((neighborPriority == declaredDesignatedRouterPriority) &&
00245                      (neighborID > declaredDesignatedRouterID)))
00246                 {
00247                     declaredDesignatedRouter = neighborsDesignatedRouter;
00248                     declaredDesignatedRouterPriority = neighborPriority;
00249                     declaredDesignatedRouterID = neighborID;
00250                     designatedRouterDeclared = true;
00251                 }
00252             }
00253         }
00254         // also include the router itself in the calculations
00255         if (intf->routerPriority > 0) {
00256             if (currentDesignatedRouter.routerID == routerID) {
00257                 if ((intf->routerPriority > declaredDesignatedRouterPriority) ||
00258                     ((intf->routerPriority == declaredDesignatedRouterPriority) &&
00259                      (routerID > declaredDesignatedRouterID)))
00260                 {
00261                     declaredDesignatedRouter.routerID = routerID;
00262                     declaredDesignatedRouter.ipInterfaceAddress = intf->interfaceAddressRange.address;
00263                     declaredDesignatedRouterPriority = intf->routerPriority;
00264                     declaredDesignatedRouterID = routerID;
00265                     designatedRouterDeclared = true;
00266                 }
00267 
00268             }
00269         }
00270         if (!designatedRouterDeclared) {
00271             declaredDesignatedRouter = declaredBackup;
00272             declaredDesignatedRouterPriority = declaredBackupPriority;
00273             declaredDesignatedRouterID = declaredBackupID;
00274             designatedRouterDeclared = true;
00275         }
00276 
00277         // if the router is any kind of DR or is no longer one of them, then repeat
00278         if (((declaredDesignatedRouter.routerID != OSPF::NullRouterID) &&
00279              ((currentDesignatedRouter.routerID == routerID) &&
00280               (declaredDesignatedRouter.routerID != routerID)) ||
00281              ((currentDesignatedRouter.routerID != routerID) &&
00282               (declaredDesignatedRouter.routerID == routerID))) ||
00283             ((declaredBackup.routerID != OSPF::NullRouterID) &&
00284              ((currentBackupRouter.routerID == routerID) &&
00285               (declaredBackup.routerID != routerID)) ||
00286              ((currentBackupRouter.routerID != routerID) &&
00287               (declaredBackup.routerID == routerID))))
00288         {
00289             currentDesignatedRouter = declaredDesignatedRouter;
00290             currentBackupRouter = declaredBackup;
00291             repeatCount++;
00292         } else {
00293             repeatCount += 2;
00294         }
00295 
00296     } while (repeatCount < 2);
00297 
00298     OSPF::RouterID routersOldDesignatedRouterID = intf->designatedRouter.routerID;
00299     OSPF::RouterID routersOldBackupID           = intf->backupDesignatedRouter.routerID;
00300 
00301     intf->designatedRouter = declaredDesignatedRouter;
00302     intf->backupDesignatedRouter = declaredBackup;
00303 
00304     bool wasBackupDesignatedRouter = (routersOldBackupID == routerID);
00305     bool wasDesignatedRouter       = (routersOldDesignatedRouterID == routerID);
00306     bool wasOther                  = (intf->GetState() == OSPF::Interface::NotDesignatedRouterState);
00307     bool wasWaiting                = (!wasBackupDesignatedRouter && !wasDesignatedRouter && !wasOther);
00308     bool isBackupDesignatedRouter  = (declaredBackup.routerID == routerID);
00309     bool isDesignatedRouter        = (declaredDesignatedRouter.routerID == routerID);
00310     bool isOther                   = (!isBackupDesignatedRouter && !isDesignatedRouter);
00311 
00312     if (wasBackupDesignatedRouter) {
00313         if (isDesignatedRouter) {
00314             ChangeState(intf, new OSPF::InterfaceStateDesignatedRouter, this);
00315         }
00316         if (isOther) {
00317             ChangeState(intf, new OSPF::InterfaceStateNotDesignatedRouter, this);
00318         }
00319     }
00320     if (wasDesignatedRouter) {
00321         if (isBackupDesignatedRouter) {
00322             ChangeState(intf, new OSPF::InterfaceStateBackup, this);
00323         }
00324         if (isOther) {
00325             ChangeState(intf, new OSPF::InterfaceStateNotDesignatedRouter, this);
00326         }
00327     }
00328     if (wasOther) {
00329         if (isDesignatedRouter) {
00330             ChangeState(intf, new OSPF::InterfaceStateDesignatedRouter, this);
00331         }
00332         if (isBackupDesignatedRouter) {
00333             ChangeState(intf, new OSPF::InterfaceStateBackup, this);
00334         }
00335     }
00336     if (wasWaiting) {
00337         if (isDesignatedRouter) {
00338             ChangeState(intf, new OSPF::InterfaceStateDesignatedRouter, this);
00339         }
00340         if (isBackupDesignatedRouter) {
00341             ChangeState(intf, new OSPF::InterfaceStateBackup, this);
00342         }
00343         if (isOther) {
00344             ChangeState(intf, new OSPF::InterfaceStateNotDesignatedRouter, this);
00345         }
00346     }
00347 
00348     for (i = 0; i < neighborCount; i++) {
00349         if ((intf->interfaceType == OSPF::Interface::NBMA) &&
00350             ((!wasBackupDesignatedRouter && isBackupDesignatedRouter) ||
00351              (!wasDesignatedRouter && isDesignatedRouter)))
00352         {
00353             if (intf->neighboringRouters[i]->GetPriority() == 0) {
00354                 intf->neighboringRouters[i]->ProcessEvent(OSPF::Neighbor::Start);
00355             }
00356         }
00357         if ((declaredDesignatedRouter.routerID != routersOldDesignatedRouterID) ||
00358             (declaredBackup.routerID != routersOldBackupID))
00359         {
00360             if (intf->neighboringRouters[i]->GetState() >= OSPF::Neighbor::TwoWayState) {
00361                 intf->neighboringRouters[i]->ProcessEvent(OSPF::Neighbor::IsAdjacencyOK);
00362             }
00363         }
00364     }
00365 }

virtual void OSPF::InterfaceState::ProcessEvent ( Interface intf,
Interface::InterfaceEventType  event 
) [pure virtual]

virtual Interface::InterfaceStateType OSPF::InterfaceState::GetState ( void   )  const [pure virtual]


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

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