#include <OSPFInterface.h>
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 };
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 };
00030 { 00031 UnknownType = 0, 00032 PointToPoint = 1, 00033 Broadcast = 2, 00034 NBMA = 3, 00035 PointToMultiPoint = 4, 00036 Virtual = 5 00037 };
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 }
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 | |||
) |
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] |
OSPFTimer* OSPF::Interface::GetAcknowledgementTimer | ( | void | ) | [inline] |
IPv4AddressRange OSPF::Interface::GetAddressRange | ( | void | ) | const [inline] |
const Area* OSPF::Interface::GetArea | ( | void | ) | const [inline] |
Area* OSPF::Interface::GetArea | ( | void | ) | [inline] |
AuthenticationKeyType OSPF::Interface::GetAuthenticationKey | ( | void | ) | const [inline] |
AuthenticationType OSPF::Interface::GetAuthenticationType | ( | void | ) | const [inline] |
DesignatedRouterID OSPF::Interface::GetBackupDesignatedRouter | ( | void | ) | const [inline] |
DesignatedRouterID OSPF::Interface::GetDesignatedRouter | ( | void | ) | const [inline] |
short OSPF::Interface::GetHelloInterval | ( | void | ) | const [inline] |
OSPFTimer* OSPF::Interface::GetHelloTimer | ( | void | ) | [inline] |
unsigned char OSPF::Interface::GetIfIndex | ( | void | ) | const [inline] |
unsigned short OSPF::Interface::GetMTU | ( | void | ) | const [inline] |
const Neighbor* OSPF::Interface::GetNeighbor | ( | unsigned long | i | ) | const [inline] |
Neighbor* OSPF::Interface::GetNeighbor | ( | unsigned long | i | ) | [inline] |
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] |
Metric OSPF::Interface::GetOutputCost | ( | void | ) | const [inline] |
short OSPF::Interface::GetPollInterval | ( | void | ) | const [inline] |
short OSPF::Interface::GetRetransmissionInterval | ( | void | ) | const [inline] |
short OSPF::Interface::GetRouterDeadInterval | ( | void | ) | const [inline] |
unsigned char OSPF::Interface::GetRouterPriority | ( | void | ) | const [inline] |
OSPF::Interface::InterfaceStateType OSPF::Interface::GetState | ( | void | ) | const |
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] |
short OSPF::Interface::GetTransmissionDelay | ( | void | ) | const [inline] |
OSPFInterfaceType OSPF::Interface::GetType | ( | void | ) | const [inline] |
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 | ) |
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] |
void OSPF::Interface::SetAddressRange | ( | IPv4AddressRange | range | ) | [inline] |
void OSPF::Interface::SetArea | ( | Area * | area | ) | [inline] |
void OSPF::Interface::SetAuthenticationKey | ( | AuthenticationKeyType | key | ) | [inline] |
void OSPF::Interface::SetAuthenticationType | ( | AuthenticationType | type | ) | [inline] |
void OSPF::Interface::SetHelloInterval | ( | short | interval | ) | [inline] |
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] |
void OSPF::Interface::SetOutputCost | ( | Metric | cost | ) | [inline] |
void OSPF::Interface::SetPollInterval | ( | short | interval | ) | [inline] |
void OSPF::Interface::SetRetransmissionInterval | ( | short | interval | ) | [inline] |
void OSPF::Interface::SetRouterDeadInterval | ( | short | interval | ) | [inline] |
void OSPF::Interface::SetRouterPriority | ( | unsigned char | priority | ) | [inline] |
void OSPF::Interface::SetTransitAreaID | ( | AreaID | areaId | ) | [inline] |
void OSPF::Interface::SetTransmissionDelay | ( | short | delay | ) | [inline] |
void OSPF::Interface::SetType | ( | OSPFInterfaceType | ifType | ) | [inline] |
friend class InterfaceState [friend] |
short OSPF::Interface::acknowledgementDelay [private] |
OSPFTimer* OSPF::Interface::acknowledgementTimer [private] |
AreaID OSPF::Interface::areaID [private] |
std::map<IPv4Address, std::list<OSPFLSAHeader>, IPv4Address_Less> OSPF::Interface::delayedAcknowledgements [private] |
short OSPF::Interface::helloInterval [private] |
OSPFTimer* OSPF::Interface::helloTimer [private] |
unsigned char OSPF::Interface::ifIndex [private] |
Metric OSPF::Interface::interfaceOutputCost [private] |
short OSPF::Interface::interfaceTransmissionDelay [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] |