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)
NeighborGetNeighborByID (RouterID neighborID)
NeighborGetNeighborByAddress (IPv4Address address)
void AddNeighbor (Neighbor *neighbor)
InterfaceStateType GetState (void) const
bool HasAnyNeighborInStates (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 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
OSPFTimer * GetHelloTimer (void)
OSPFTimer * GetWaitTimer (void)
OSPFTimer * GetAcknowledgementTimer (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
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
AreaparentArea

Friends

class InterfaceState


Member Enumeration Documentation

Enumerator:
InterfaceUp 
HelloTimer 
WaitTimer 
AcknowledgementTimer 
BackupSeen 
NeighborChange 
LoopIndication 
UnloopIndication 
InterfaceDown 
00036                             {
00037         InterfaceUp          = 0,
00038         HelloTimer           = 1,
00039         WaitTimer            = 2,
00040         AcknowledgementTimer = 3,
00041         BackupSeen           = 4,
00042         NeighborChange       = 5,
00043         LoopIndication       = 6,
00044         UnloopIndication     = 7,
00045         InterfaceDown        = 8
00046     };

Enumerator:
UnknownType 
PointToPoint 
Broadcast 
NBMA 
PointToMultiPoint 
Virtual 
00048                            {
00049         UnknownType       = 0,
00050         PointToPoint      = 1,
00051         Broadcast         = 2,
00052         NBMA              = 3,
00053         PointToMultiPoint = 4,
00054         Virtual           = 5
00055     };

Enumerator:
DownState 
LoopbackState 
WaitingState 
PointToPointState 
NotDesignatedRouterState 
BackupState 
DesignatedRouterState 
00057                             {
00058         DownState                = 0,
00059         LoopbackState            = 1,
00060         WaitingState             = 2,
00061         PointToPointState        = 3,
00062         NotDesignatedRouterState = 4,
00063         BackupState              = 5,
00064         DesignatedRouterState    = 6
00065     };


Constructor & Destructor Documentation

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

00028                                                               :
00029     interfaceType(ifType),
00030     ifIndex(0),
00031     mtu(0),
00032     interfaceAddressRange(OSPF::NullIPv4AddressRange),
00033     areaID(OSPF::BackboneAreaID),
00034     transitAreaID(OSPF::BackboneAreaID),
00035     helloInterval(10),
00036     pollInterval(120),
00037     routerDeadInterval(40),
00038     interfaceTransmissionDelay(1),
00039     routerPriority(0),
00040     designatedRouter(OSPF::NullDesignatedRouterID),
00041     backupDesignatedRouter(OSPF::NullDesignatedRouterID),
00042     interfaceOutputCost(1),
00043     retransmissionInterval(5),
00044     acknowledgementDelay(1),
00045     authenticationType(OSPF::NullType),
00046     parentArea(NULL)
00047 {
00048     state = new OSPF::InterfaceStateDown;
00049     previousState = NULL;
00050     helloTimer = new OSPFTimer;
00051     helloTimer->setTimerKind(InterfaceHelloTimer);
00052     helloTimer->setContextPointer(this);
00053     helloTimer->setName("OSPF::Interface::InterfaceHelloTimer");
00054     waitTimer = new OSPFTimer;
00055     waitTimer->setTimerKind(InterfaceWaitTimer);
00056     waitTimer->setContextPointer(this);
00057     waitTimer->setName("OSPF::Interface::InterfaceWaitTimer");
00058     acknowledgementTimer = new OSPFTimer;
00059     acknowledgementTimer->setTimerKind(InterfaceAcknowledgementTimer);
00060     acknowledgementTimer->setContextPointer(this);
00061     acknowledgementTimer->setName("OSPF::Interface::InterfaceAcknowledgementTimer");
00062     memset(authenticationKey.bytes, 0, 8 * sizeof(char));
00063 }

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

00066 {
00067     MessageHandler* messageHandler = parentArea->GetRouter()->GetMessageHandler();
00068     messageHandler->ClearTimer(helloTimer);
00069     delete helloTimer;
00070     messageHandler->ClearTimer(waitTimer);
00071     delete waitTimer;
00072     messageHandler->ClearTimer(acknowledgementTimer);
00073     delete acknowledgementTimer;
00074     if (previousState != NULL) {
00075         delete previousState;
00076     }
00077     delete state;
00078     long neighborCount = neighboringRouters.size();
00079     for (long i = 0; i < neighborCount; i++) {
00080         delete neighboringRouters[i];
00081     }
00082 }


Member Function Documentation

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

Referenced by OSPF::InterfaceState::ChangeState().

00096 {
00097     if (previousState != NULL) {
00098         delete previousState;
00099     }
00100     state = newState;
00101     previousState = currentState;
00102 }

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

Referenced by OSPF::MessageHandler::HandleTimer(), OSPFRouting::LoadInterfaceParameters(), and OSPF::HelloHandler::ProcessPacket().

00105 {
00106     state->ProcessEvent(this, event);
00107 }

void OSPF::Interface::Reset ( void   ) 

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

00110 {
00111     MessageHandler* messageHandler = parentArea->GetRouter()->GetMessageHandler();
00112     messageHandler->ClearTimer(helloTimer);
00113     messageHandler->ClearTimer(waitTimer);
00114     messageHandler->ClearTimer(acknowledgementTimer);
00115     designatedRouter = NullDesignatedRouterID;
00116     backupDesignatedRouter = NullDesignatedRouterID;
00117     long neighborCount = neighboringRouters.size();
00118     for (long i = 0; i < neighborCount; i++) {
00119         neighboringRouters[i]->ProcessEvent(OSPF::Neighbor::KillNeighbor);
00120     }
00121 }

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

Referenced by OSPF::NeighborStateDown::ProcessEvent(), OSPF::InterfaceStateWaiting::ProcessEvent(), OSPF::InterfaceStatePointToPoint::ProcessEvent(), OSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), OSPF::InterfaceStateDesignatedRouter::ProcessEvent(), OSPF::InterfaceStateBackup::ProcessEvent(), and OSPF::HelloHandler::ProcessPacket().

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

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

Referenced by OSPF::LinkStateUpdateHandler::ProcessPacket().

00171 {
00172     OSPFOptions                         options;
00173     OSPFLinkStateAcknowledgementPacket* lsAckPacket = new OSPFLinkStateAcknowledgementPacket;
00174 
00175     lsAckPacket->setType(LinkStateAcknowledgementPacket);
00176     lsAckPacket->setRouterID(parentArea->GetRouter()->GetRouterID());
00177     lsAckPacket->setAreaID(parentArea->GetAreaID());
00178     lsAckPacket->setAuthenticationType(authenticationType);
00179     for (int i = 0; i < 8; i++) {
00180         lsAckPacket->setAuthentication(i, authenticationKey.bytes[i]);
00181     }
00182 
00183     lsAckPacket->setLsaHeadersArraySize(1);
00184     lsAckPacket->setLsaHeaders(0, *lsaHeader);
00185 
00186     lsAckPacket->setPacketLength(0); // TODO: Calculate correct length
00187     lsAckPacket->setChecksum(0); // TODO: Calculate correct cheksum(16-bit one's complement of the entire packet)
00188 
00189     int ttl = (interfaceType == OSPF::Interface::Virtual) ? VIRTUAL_LINK_TTL : 1;
00190     parentArea->GetRouter()->GetMessageHandler()->SendPacket(lsAckPacket, destination, ifIndex, ttl);
00191 }

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

Referenced by OSPF::LinkStateUpdateHandler::AcknowledgeLSA(), FloodLSA(), OSPF::MessageHandler::ProcessPacket(), and OSPF::HelloHandler::ProcessPacket().

00195 {
00196     std::map<OSPF::RouterID, OSPF::Neighbor*>::iterator neighborIt = neighboringRoutersByID.find(neighborID);
00197     if (neighborIt != neighboringRoutersByID.end()) {
00198         return (neighborIt->second);
00199     }
00200     else {
00201         return NULL;
00202     }
00203 }

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

Referenced by OSPF::Area::OriginateRouterLSA(), OSPF::MessageHandler::ProcessPacket(), and OSPF::HelloHandler::ProcessPacket().

00206 {
00207     std::map<OSPF::IPv4Address, OSPF::Neighbor*, OSPF::IPv4Address_Less>::iterator neighborIt = neighboringRoutersByAddress.find(address);
00208     if (neighborIt != neighboringRoutersByAddress.end()) {
00209         return (neighborIt->second);
00210     }
00211     else {
00212         return NULL;
00213     }
00214 }

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

Referenced by OSPFRouting::LoadInterfaceParameters(), OSPFRouting::LoadVirtualLink(), and OSPF::HelloHandler::ProcessPacket().

00217 {
00218     neighboringRoutersByID[neighbor->GetNeighborID()] = neighbor;
00219     neighboringRoutersByAddress[neighbor->GetAddress()] = neighbor;
00220     neighbor->SetInterface(this);
00221     neighboringRouters.push_back(neighbor);
00222 }

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

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

Referenced by OSPF::MessageHandler::PrintEvent().

00230 {
00231     switch (stateType) {
00232         case DownState:                 return "Down";
00233         case LoopbackState:             return "Loopback";
00234         case WaitingState:              return "Waiting";
00235         case PointToPointState:         return "PointToPoint";
00236         case NotDesignatedRouterState:  return "NotDesignatedRouter";
00237         case BackupState:               return "Backup";
00238         case DesignatedRouterState:     return "DesignatedRouter";
00239         default:                        ASSERT(false);
00240     }
00241     return "";
00242 }

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

Referenced by OSPF::Area::AgeDatabase(), OSPF::Area::OriginateNetworkLSA(), and OSPF::Area::OriginateRouterLSA().

00245 {
00246     long neighborCount = neighboringRouters.size();
00247     for (long i = 0; i < neighborCount; i++) {
00248         OSPF::Neighbor::NeighborStateType neighborState = neighboringRouters[i]->GetState();
00249         if (neighborState & states) {
00250             return true;
00251         }
00252     }
00253     return false;
00254 }

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

00257 {
00258     long neighborCount = neighboringRouters.size();
00259     for (long i = 0; i < neighborCount; i++) {
00260         neighboringRouters[i]->RemoveFromRetransmissionList(lsaKey);
00261     }
00262 }

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

00265 {
00266     long neighborCount = neighboringRouters.size();
00267     for (long i = 0; i < neighborCount; i++) {
00268         if (neighboringRouters[i]->IsLSAOnRetransmissionList(lsaKey)) {
00269             return true;
00270         }
00271     }
00272     return false;
00273 }

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

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

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

Referenced by OSPF::LinkStateUpdateHandler::AcknowledgeLSA().

00496 {
00497     if (interfaceType == OSPF::Interface::Broadcast) {
00498         if ((GetState() == OSPF::Interface::DesignatedRouterState) ||
00499             (GetState() == OSPF::Interface::BackupState) ||
00500             (designatedRouter == OSPF::NullDesignatedRouterID))
00501         {
00502             delayedAcknowledgements[OSPF::AllSPFRouters].push_back(lsaHeader);
00503         } else {
00504             delayedAcknowledgements[OSPF::AllDRouters].push_back(lsaHeader);
00505         }
00506     } else {
00507         long neighborCount = neighboringRouters.size();
00508         for (long i = 0; i < neighborCount; i++) {
00509             if (neighboringRouters[i]->GetState() >= OSPF::Neighbor::ExchangeState) {
00510                 delayedAcknowledgements[neighboringRouters[i]->GetAddress()].push_back(lsaHeader);
00511             }
00512         }
00513     }
00514 }

void OSPF::Interface::SendDelayedAcknowledgements ( void   ) 

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

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

void OSPF::Interface::AgeTransmittedLSALists ( void   ) 

00575 {
00576     long neighborCount = neighboringRouters.size();
00577     for (long i = 0; i < neighborCount; i++) {
00578         neighboringRouters[i]->AgeTransmittedLSAList();
00579     }
00580 }

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

Referenced by FloodLSA(), OSPF::LinkStateUpdateHandler::ProcessPacket(), and OSPF::LinkStateRequestHandler::ProcessPacket().

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

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

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

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

Referenced by OSPFRouting::LoadInterfaceParameters().

00085 {
00086     ifIndex = index;
00087     if (interfaceType == OSPF::Interface::UnknownType) {
00088         InterfaceEntry* routingInterface = InterfaceTableAccess().get()->getInterfaceById(ifIndex);
00089         interfaceAddressRange.address = IPv4AddressFromAddressString(routingInterface->ipv4Data()->getIPAddress().str().c_str());
00090         interfaceAddressRange.mask = IPv4AddressFromAddressString(routingInterface->ipv4Data()->getNetmask().str().c_str());
00091         mtu = routingInterface->getMTU();
00092     }
00093 }

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

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

00128 { mtu = ifMTU; }

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

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

Referenced by OSPFRouting::LoadInterfaceParameters().

00130 { areaID = areaId; }

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

Referenced by OSPFRouting::LoadVirtualLink().

00131 { return areaID; }

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

Referenced by OSPFRouting::LoadVirtualLink().

00132 { transitAreaID = areaId; }

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

Referenced by OSPF::MessageHandler::ProcessPacket().

00133 { return transitAreaID; }

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

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

Referenced by OSPF::Area::OriginateRouterLSA().

00135 { return interfaceOutputCost; }

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

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

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

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

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

00140 { acknowledgementDelay = delay; }

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

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

Referenced by OSPFRouting::LoadInterfaceParameters().

00142 { routerPriority = priority; }

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

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

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

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

Referenced by OSPFRouting::LoadInterfaceParameters().

00146 { pollInterval = interval; }

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

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

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

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

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

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

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

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

00154 { interfaceAddressRange = range; }

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

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

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

Referenced by OSPF::InterfaceStateDown::ProcessEvent().

00158 { return waitTimer; }

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

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

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

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

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

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

00164 { return neighboringRouters[i]; }

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

Referenced by OSPF::Area::AddInterface().

00166 { parentArea = area; }

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

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

00168 { return parentArea; }


Friends And Related Function Documentation

friend class InterfaceState [friend]


Member Data Documentation

Referenced by ChangeState(), Interface(), and ~Interface().

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

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

Referenced by GetPollInterval(), and SetPollInterval().

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

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

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

Referenced by AddNeighbor(), and GetNeighborByID().

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

Referenced by GetOutputCost(), and SetOutputCost().


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