#include <OSPFInterface.h>
|
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 };
|
|
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 };
|
|
00011 : 00012 interfaceType (ifType), 00013 ifIndex (0), 00014 mtu (0), 00015 interfaceAddressRange (OSPF::NullIPv4AddressRange), 00016 areaID (OSPF::BackboneAreaID), 00017 helloInterval (10), 00018 pollInterval (120), 00019 routerDeadInterval (40), 00020 interfaceTransmissionDelay (1), 00021 routerPriority (0), 00022 designatedRouter (OSPF::NullDesignatedRouterID), 00023 backupDesignatedRouter (OSPF::NullDesignatedRouterID), 00024 interfaceOutputCost (1), 00025 retransmissionInterval (5), 00026 acknowledgementDelay (1), 00027 authenticationType (OSPF::NullType), 00028 parentArea (NULL) 00029 { 00030 state = new OSPF::InterfaceStateDown; 00031 previousState = NULL; 00032 helloTimer = new OSPFTimer; 00033 helloTimer->setTimerKind (InterfaceHelloTimer); 00034 helloTimer->setContextPointer (this); 00035 helloTimer->setName ("OSPF::Interface::InterfaceHelloTimer"); 00036 waitTimer = new OSPFTimer; 00037 waitTimer->setTimerKind (InterfaceWaitTimer); 00038 waitTimer->setContextPointer (this); 00039 waitTimer->setName ("OSPF::Interface::InterfaceWaitTimer"); 00040 acknowledgementTimer = new OSPFTimer; 00041 acknowledgementTimer->setTimerKind (InterfaceAcknowledgementTimer); 00042 acknowledgementTimer->setContextPointer (this); 00043 acknowledgementTimer->setName ("OSPF::Interface::InterfaceAcknowledgementTimer"); 00044 memset (authenticationKey.bytes, 0, 8 * sizeof (char)); 00045 }
|
|
00048 { 00049 MessageHandler* messageHandler = parentArea->GetRouter ()->GetMessageHandler (); 00050 messageHandler->ClearTimer (helloTimer); 00051 delete helloTimer; 00052 messageHandler->ClearTimer (waitTimer); 00053 delete waitTimer; 00054 messageHandler->ClearTimer (acknowledgementTimer); 00055 delete acknowledgementTimer; 00056 if (previousState != NULL) { 00057 delete previousState; 00058 } 00059 delete state; 00060 long neighborCount = neighboringRouters.size (); 00061 for (long i = 0; i < neighborCount; i++) { 00062 delete neighboringRouters[i]; 00063 } 00064 }
|
|
00478 { 00479 if (interfaceType == OSPF::Interface::Broadcast) { 00480 if ((GetState () == OSPF::Interface::DesignatedRouterState) || 00481 (GetState () == OSPF::Interface::BackupState) || 00482 (designatedRouter == OSPF::NullDesignatedRouterID)) 00483 { 00484 delayedAcknowledgements[OSPF::AllSPFRouters].push_back (lsaHeader); 00485 } else { 00486 delayedAcknowledgements[OSPF::AllDRouters].push_back (lsaHeader); 00487 } 00488 } else { 00489 long neighborCount = neighboringRouters.size (); 00490 for (long i = 0; i < neighborCount; i++) { 00491 if (neighboringRouters[i]->GetState () >= OSPF::Neighbor::ExchangeState) { 00492 delayedAcknowledgements[neighboringRouters[i]->GetAddress ()].push_back (lsaHeader); 00493 } 00494 } 00495 } 00496 }
|
|
00199 { 00200 neighboringRoutersByID[neighbor->GetNeighborID ()] = neighbor; 00201 neighboringRoutersByAddress[neighbor->GetAddress ()] = neighbor; 00202 neighbor->SetInterface (this); 00203 neighboringRouters.push_back (neighbor); 00204 }
|
|
00557 { 00558 long neighborCount = neighboringRouters.size (); 00559 for (long i = 0; i < neighborCount; i++) { 00560 neighboringRouters[i]->AgeTransmittedLSAList (); 00561 } 00562 }
|
|
00227 { 00228 long neighborCount = neighboringRouters.size (); 00229 for (long i = 0; i < neighborCount; i++) { 00230 OSPF::Neighbor::NeighborStateType neighborState = neighboringRouters[i]->GetState (); 00231 if (neighborState & states) { 00232 return true; 00233 } 00234 } 00235 return false; 00236 }
|
|
00078 { 00079 if (previousState != NULL) { 00080 delete previousState; 00081 } 00082 state = newState; 00083 previousState = currentState; 00084 }
|
|
00391 { 00392 LSAType lsaType = static_cast<LSAType> (lsa->getHeader ().getLsType ()); 00393 OSPFRouterLSA* routerLSA = (lsaType == RouterLSAType) ? dynamic_cast<OSPFRouterLSA*> (lsa) : NULL; 00394 OSPFNetworkLSA* networkLSA = (lsaType == NetworkLSAType) ? dynamic_cast<OSPFNetworkLSA*> (lsa) : NULL; 00395 OSPFSummaryLSA* summaryLSA = ((lsaType == SummaryLSA_NetworksType) || 00396 (lsaType == SummaryLSA_ASBoundaryRoutersType)) ? dynamic_cast<OSPFSummaryLSA*> (lsa) : NULL; 00397 OSPFASExternalLSA* asExternalLSA = (lsaType == ASExternalLSAType) ? dynamic_cast<OSPFASExternalLSA*> (lsa) : NULL; 00398 00399 if (((lsaType == RouterLSAType) && (routerLSA != NULL)) || 00400 ((lsaType == NetworkLSAType) && (networkLSA != NULL)) || 00401 (((lsaType == SummaryLSA_NetworksType) || (lsaType == SummaryLSA_ASBoundaryRoutersType)) && (summaryLSA != NULL)) || 00402 ((lsaType == ASExternalLSAType) && (asExternalLSA != NULL))) 00403 { 00404 OSPFLinkStateUpdatePacket* updatePacket = new OSPFLinkStateUpdatePacket; 00405 00406 updatePacket->setType (LinkStateUpdatePacket); 00407 updatePacket->setRouterID (parentArea->GetRouter ()->GetRouterID ()); 00408 updatePacket->setAreaID (areaID); 00409 updatePacket->setAuthenticationType (authenticationType); 00410 for (int j = 0; j < 8; j++) { 00411 updatePacket->setAuthentication (j, authenticationKey.bytes[j]); 00412 } 00413 00414 updatePacket->setNumberOfLSAs (1); 00415 00416 switch (lsaType) { 00417 case RouterLSAType: 00418 { 00419 updatePacket->setRouterLSAsArraySize (1); 00420 updatePacket->setRouterLSAs (0, *routerLSA); 00421 unsigned short lsAge = updatePacket->getRouterLSAs (0).getHeader ().getLsAge (); 00422 if (lsAge < MAX_AGE - interfaceTransmissionDelay) { 00423 updatePacket->getRouterLSAs (0).getHeader ().setLsAge (lsAge + interfaceTransmissionDelay); 00424 } else { 00425 updatePacket->getRouterLSAs (0).getHeader ().setLsAge (MAX_AGE); 00426 } 00427 } 00428 break; 00429 case NetworkLSAType: 00430 { 00431 updatePacket->setNetworkLSAsArraySize (1); 00432 updatePacket->setNetworkLSAs (0, *networkLSA); 00433 unsigned short lsAge = updatePacket->getNetworkLSAs (0).getHeader ().getLsAge (); 00434 if (lsAge < MAX_AGE - interfaceTransmissionDelay) { 00435 updatePacket->getNetworkLSAs (0).getHeader ().setLsAge (lsAge + interfaceTransmissionDelay); 00436 } else { 00437 updatePacket->getNetworkLSAs (0).getHeader ().setLsAge (MAX_AGE); 00438 } 00439 } 00440 break; 00441 case SummaryLSA_NetworksType: 00442 case SummaryLSA_ASBoundaryRoutersType: 00443 { 00444 updatePacket->setSummaryLSAsArraySize (1); 00445 updatePacket->setSummaryLSAs (0, *summaryLSA); 00446 unsigned short lsAge = updatePacket->getSummaryLSAs (0).getHeader ().getLsAge (); 00447 if (lsAge < MAX_AGE - interfaceTransmissionDelay) { 00448 updatePacket->getSummaryLSAs (0).getHeader ().setLsAge (lsAge + interfaceTransmissionDelay); 00449 } else { 00450 updatePacket->getSummaryLSAs (0).getHeader ().setLsAge (MAX_AGE); 00451 } 00452 } 00453 break; 00454 case ASExternalLSAType: 00455 { 00456 updatePacket->setAsExternalLSAsArraySize (1); 00457 updatePacket->setAsExternalLSAs (0, *asExternalLSA); 00458 unsigned short lsAge = updatePacket->getAsExternalLSAs (0).getHeader ().getLsAge (); 00459 if (lsAge < MAX_AGE - interfaceTransmissionDelay) { 00460 updatePacket->getAsExternalLSAs (0).getHeader ().setLsAge (lsAge + interfaceTransmissionDelay); 00461 } else { 00462 updatePacket->getAsExternalLSAs (0).getHeader ().setLsAge (MAX_AGE); 00463 } 00464 } 00465 break; 00466 default: break; 00467 } 00468 00469 updatePacket->setPacketLength (0); // TODO: Calculate correct length 00470 updatePacket->setChecksum (0); // TODO: Calculate correct cheksum (16-bit one's complement of the entire packet) 00471 00472 return updatePacket; 00473 } 00474 return NULL; 00475 }
|
|
00261 { 00262 bool floodedBackOut = false; 00263 00264 if ( 00265 ( 00266 (lsa->getHeader ().getLsType () == ASExternalLSAType) && 00267 (interfaceType != OSPF::Interface::Virtual) && 00268 (parentArea->GetExternalRoutingCapability ()) 00269 ) || 00270 ( 00271 (lsa->getHeader ().getLsType () != ASExternalLSAType) && 00272 ( 00273 ( 00274 (areaID != OSPF::BackboneAreaID) && 00275 (interfaceType != OSPF::Interface::Virtual) 00276 ) || 00277 (areaID == OSPF::BackboneAreaID) 00278 ) 00279 ) 00280 ) 00281 { 00282 long neighborCount = neighboringRouters.size (); 00283 bool lsaAddedToRetransmissionList = false; 00284 OSPF::LinkStateID linkStateID = lsa->getHeader ().getLinkStateID (); 00285 OSPF::LSAKeyType lsaKey; 00286 00287 lsaKey.linkStateID = linkStateID; 00288 lsaKey.advertisingRouter = lsa->getHeader ().getAdvertisingRouter ().getInt (); 00289 00290 for (long i = 0; i < neighborCount; i++) { // (1) 00291 if (neighboringRouters[i]->GetState () < OSPF::Neighbor::ExchangeState) { // (1) (a) 00292 continue; 00293 } 00294 if (neighboringRouters[i]->GetState () < OSPF::Neighbor::FullState) { // (1) (b) 00295 OSPFLSAHeader* requestLSAHeader = neighboringRouters[i]->FindOnRequestList (lsaKey); 00296 if (requestLSAHeader != NULL) { 00297 // operator< and operator== on OSPFLSAHeaders determines which one is newer (less means older) 00298 if (lsa->getHeader () < (*requestLSAHeader)) { 00299 continue; 00300 } 00301 if (operator== (lsa->getHeader (), (*requestLSAHeader))) { 00302 neighboringRouters[i]->RemoveFromRequestList (lsaKey); 00303 continue; 00304 } 00305 neighboringRouters[i]->RemoveFromRequestList (lsaKey); 00306 } 00307 } 00308 if (neighbor == neighboringRouters[i]) { // (1) (c) 00309 continue; 00310 } 00311 neighboringRouters[i]->AddToRetransmissionList (lsa); // (1) (d) 00312 lsaAddedToRetransmissionList = true; 00313 } 00314 if (lsaAddedToRetransmissionList) { // (2) 00315 if ((intf != this) || 00316 ((neighbor != NULL) && 00317 (neighbor->GetNeighborID () != designatedRouter.routerID) && 00318 (neighbor->GetNeighborID () != backupDesignatedRouter.routerID))) // (3) 00319 { 00320 if ((intf != this) || (GetState () != OSPF::Interface::BackupState)) { // (4) 00321 OSPFLinkStateUpdatePacket* updatePacket = CreateUpdatePacket (lsa); // (5) 00322 00323 if (updatePacket != NULL) { 00324 int ttl = (interfaceType == OSPF::Interface::Virtual) ? VIRTUAL_LINK_TTL : 1; 00325 OSPF::MessageHandler* messageHandler = parentArea->GetRouter ()->GetMessageHandler (); 00326 00327 if (interfaceType == OSPF::Interface::Broadcast) { 00328 if ((GetState () == OSPF::Interface::DesignatedRouterState) || 00329 (GetState () == OSPF::Interface::BackupState) || 00330 (designatedRouter == OSPF::NullDesignatedRouterID)) 00331 { 00332 messageHandler->SendPacket (updatePacket, OSPF::AllSPFRouters, ifIndex, ttl); 00333 for (long k = 0; k < neighborCount; k++) { 00334 neighboringRouters[k]->AddToTransmittedLSAList (lsaKey); 00335 if (!neighboringRouters[k]->IsUpdateRetransmissionTimerActive ()) { 00336 neighboringRouters[k]->StartUpdateRetransmissionTimer (); 00337 } 00338 } 00339 } else { 00340 messageHandler->SendPacket (updatePacket, OSPF::AllDRouters, ifIndex, ttl); 00341 OSPF::Neighbor* dRouter = GetNeighborByID (designatedRouter.routerID); 00342 OSPF::Neighbor* backupDRouter = GetNeighborByID (backupDesignatedRouter.routerID); 00343 if (dRouter != NULL) { 00344 dRouter->AddToTransmittedLSAList (lsaKey); 00345 if (!dRouter->IsUpdateRetransmissionTimerActive ()) { 00346 dRouter->StartUpdateRetransmissionTimer (); 00347 } 00348 } 00349 if (backupDRouter != NULL) { 00350 backupDRouter->AddToTransmittedLSAList (lsaKey); 00351 if (!backupDRouter->IsUpdateRetransmissionTimerActive ()) { 00352 backupDRouter->StartUpdateRetransmissionTimer (); 00353 } 00354 } 00355 } 00356 } else { 00357 if (interfaceType == OSPF::Interface::PointToPoint) { 00358 messageHandler->SendPacket (updatePacket, OSPF::AllSPFRouters, ifIndex, ttl); 00359 if (neighborCount > 0) { 00360 neighboringRouters[0]->AddToTransmittedLSAList (lsaKey); 00361 if (!neighboringRouters[0]->IsUpdateRetransmissionTimerActive ()) { 00362 neighboringRouters[0]->StartUpdateRetransmissionTimer (); 00363 } 00364 } 00365 } else { 00366 for (long m = 0; m < neighborCount; m++) { 00367 if (neighboringRouters[m]->GetState () >= OSPF::Neighbor::ExchangeState) { 00368 messageHandler->SendPacket (updatePacket, neighboringRouters[m]->GetAddress (), ifIndex, ttl); 00369 neighboringRouters[m]->AddToTransmittedLSAList (lsaKey); 00370 if (!neighboringRouters[m]->IsUpdateRetransmissionTimerActive ()) { 00371 neighboringRouters[m]->StartUpdateRetransmissionTimer (); 00372 } 00373 } 00374 } 00375 } 00376 } 00377 00378 if (intf == this) { 00379 floodedBackOut = true; 00380 } 00381 } 00382 } 00383 } 00384 } 00385 } 00386 00387 return floodedBackOut; 00388 }
|
|
00120 { return acknowledgementDelay; }
|
|
00138 { return acknowledgementTimer; }
|
|
00134 { return interfaceAddressRange; }
|
|
00147 { return parentArea; }
|
|
00146 { return parentArea; }
|
|
00112 { return areaID; }
|
|
00132 { return authenticationKey; }
|
|
00130 { return authenticationType; }
|
|
00140 { return backupDesignatedRouter; }
|
|
00139 { return designatedRouter; }
|
|
00124 { return helloInterval; }
|
|
00136 { return helloTimer; }
|
|
00108 { return ifIndex; }
|
|
00110 { return mtu; }
|
|
00143 { return neighboringRouters[i]; }
|
|
00142 { return neighboringRouters[i]; }
|
|
00188 { 00189 std::map<OSPF::IPv4Address, OSPF::Neighbor*, OSPF::IPv4Address_Less>::iterator neighborIt = neighboringRoutersByAddress.find (address); 00190 if (neighborIt != neighboringRoutersByAddress.end ()) { 00191 return (neighborIt->second); 00192 } 00193 else { 00194 return NULL; 00195 } 00196 }
|
|
00177 { 00178 std::map<OSPF::RouterID, OSPF::Neighbor*>::iterator neighborIt = neighboringRoutersByID.find (neighborID); 00179 if (neighborIt != neighboringRoutersByID.end ()) { 00180 return (neighborIt->second); 00181 } 00182 else { 00183 return NULL; 00184 } 00185 }
|
|
00141 { return neighboringRouters.size (); }
|
|
00114 { return interfaceOutputCost; }
|
|
00126 { return pollInterval; }
|
|
00116 { return retransmissionInterval; }
|
|
00128 { return routerDeadInterval; }
|
|
00122 { return routerPriority; }
|
|
00207 { 00208 return state->GetState (); 00209 }
|
|
00212 { 00213 switch (stateType) { 00214 case DownState: return "Down"; 00215 case LoopbackState: return "Loopback"; 00216 case WaitingState: return "Waiting"; 00217 case PointToPointState: return "PointToPoint"; 00218 case NotDesignatedRouterState: return "NotDesignatedRouter"; 00219 case BackupState: return "Backup"; 00220 case DesignatedRouterState: return "DesignatedRouter"; 00221 default: ASSERT (false); 00222 } 00223 return ""; 00224 }
|
|
00118 { return interfaceTransmissionDelay; }
|
|
00106 { return interfaceType; }
|
|
00137 { return waitTimer; }
|
|
00247 { 00248 long neighborCount = neighboringRouters.size (); 00249 for (long i = 0; i < neighborCount; i++) { 00250 if (neighboringRouters[i]->IsLSAOnRetransmissionList (lsaKey)) { 00251 return true; 00252 } 00253 } 00254 return false; 00255 }
|
|
00087 { 00088 state->ProcessEvent (this, event); 00089 }
|
|
00239 { 00240 long neighborCount = neighboringRouters.size (); 00241 for (long i = 0; i < neighborCount; i++) { 00242 neighboringRouters[i]->RemoveFromRetransmissionList (lsaKey); 00243 } 00244 }
|
|
00092 { 00093 MessageHandler* messageHandler = parentArea->GetRouter ()->GetMessageHandler (); 00094 messageHandler->ClearTimer (helloTimer); 00095 messageHandler->ClearTimer (waitTimer); 00096 messageHandler->ClearTimer (acknowledgementTimer); 00097 designatedRouter = NullDesignatedRouterID; 00098 backupDesignatedRouter = NullDesignatedRouterID; 00099 long neighborCount = neighboringRouters.size (); 00100 for (long i = 0; i < neighborCount; i++) { 00101 neighboringRouters[i]->ProcessEvent (OSPF::Neighbor::KillNeighbor); 00102 } 00103 }
|
|
00499 { 00500 OSPF::MessageHandler* messageHandler = parentArea->GetRouter ()->GetMessageHandler (); 00501 long maxPacketSize = ((IPV4_HEADER_LENGTH + OSPF_HEADER_LENGTH + OSPF_LSA_HEADER_LENGTH) > mtu) ? IPV4_DATAGRAM_LENGTH : mtu; 00502 00503 for (std::map<IPv4Address, std::list<OSPFLSAHeader>, OSPF::IPv4Address_Less>::iterator delayIt = delayedAcknowledgements.begin (); 00504 delayIt != delayedAcknowledgements.end (); 00505 delayIt++) 00506 { 00507 int ackCount = delayIt->second.size (); 00508 if (ackCount > 0) { 00509 while (!(delayIt->second.empty ())) { 00510 OSPFLinkStateAcknowledgementPacket* ackPacket = new OSPFLinkStateAcknowledgementPacket; 00511 long packetSize = IPV4_HEADER_LENGTH + OSPF_HEADER_LENGTH; 00512 00513 ackPacket->setType (LinkStateAcknowledgementPacket); 00514 ackPacket->setRouterID (parentArea->GetRouter ()->GetRouterID ()); 00515 ackPacket->setAreaID (areaID); 00516 ackPacket->setAuthenticationType (authenticationType); 00517 for (int i = 0; i < 8; i++) { 00518 ackPacket->setAuthentication (i, authenticationKey.bytes[i]); 00519 } 00520 00521 while ((!(delayIt->second.empty ())) && (packetSize <= (maxPacketSize - OSPF_LSA_HEADER_LENGTH))) { 00522 unsigned long headerCount = ackPacket->getLsaHeadersArraySize (); 00523 ackPacket->setLsaHeadersArraySize (headerCount + 1); 00524 ackPacket->setLsaHeaders (headerCount, *(delayIt->second.begin ())); 00525 delayIt->second.pop_front (); 00526 packetSize += OSPF_LSA_HEADER_LENGTH; 00527 } 00528 00529 ackPacket->setPacketLength (0); // TODO: Calculate correct length 00530 ackPacket->setChecksum (0); // TODO: Calculate correct cheksum (16-bit one's complement of the entire packet) 00531 00532 int ttl = (interfaceType == OSPF::Interface::Virtual) ? VIRTUAL_LINK_TTL : 1; 00533 00534 if (interfaceType == OSPF::Interface::Broadcast) { 00535 if ((GetState () == OSPF::Interface::DesignatedRouterState) || 00536 (GetState () == OSPF::Interface::BackupState) || 00537 (designatedRouter == OSPF::NullDesignatedRouterID)) 00538 { 00539 messageHandler->SendPacket (ackPacket, OSPF::AllSPFRouters, ifIndex, ttl); 00540 } else { 00541 messageHandler->SendPacket (ackPacket, OSPF::AllDRouters, ifIndex, ttl); 00542 } 00543 } else { 00544 if (interfaceType == OSPF::Interface::PointToPoint) { 00545 messageHandler->SendPacket (ackPacket, OSPF::AllSPFRouters, ifIndex, ttl); 00546 } else { 00547 messageHandler->SendPacket (ackPacket, delayIt->first, ifIndex, ttl); 00548 } 00549 } 00550 } 00551 } 00552 } 00553 messageHandler->StartTimer (acknowledgementTimer, acknowledgementDelay); 00554 }
|
|
00106 { 00107 OSPFOptions options; 00108 OSPFHelloPacket* helloPacket = new OSPFHelloPacket; 00109 std::vector<OSPF::IPv4Address> neighbors; 00110 00111 helloPacket->setRouterID (parentArea->GetRouter ()->GetRouterID ()); 00112 helloPacket->setAreaID (parentArea->GetAreaID ()); 00113 helloPacket->setAuthenticationType (authenticationType); 00114 for (int i = 0; i < 8; i++) { 00115 helloPacket->setAuthentication (i, authenticationKey.bytes[i]); 00116 } 00117 00118 if (((interfaceType == PointToPoint) && 00119 (interfaceAddressRange.address == OSPF::NullIPv4Address)) || 00120 (interfaceType == Virtual)) 00121 { 00122 helloPacket->setNetworkMask (ULongFromIPv4Address (OSPF::NullIPv4Address)); 00123 } else { 00124 helloPacket->setNetworkMask (ULongFromIPv4Address (interfaceAddressRange.mask)); 00125 } 00126 memset (&options, 0, sizeof (OSPFOptions)); 00127 options.E_ExternalRoutingCapability = parentArea->GetExternalRoutingCapability (); 00128 helloPacket->setOptions (options); 00129 helloPacket->setHelloInterval (helloInterval); 00130 helloPacket->setRouterPriority (routerPriority); 00131 helloPacket->setRouterDeadInterval (routerDeadInterval); 00132 helloPacket->setDesignatedRouter (ULongFromIPv4Address (designatedRouter.ipInterfaceAddress)); 00133 helloPacket->setBackupDesignatedRouter (ULongFromIPv4Address (backupDesignatedRouter.ipInterfaceAddress)); 00134 long neighborCount = neighboringRouters.size (); 00135 for (long j = 0; j < neighborCount; j++) { 00136 if (neighboringRouters[j]->GetState () >= OSPF::Neighbor::InitState) { 00137 neighbors.push_back (neighboringRouters[j]->GetAddress ()); 00138 } 00139 } 00140 unsigned int initedNeighborCount = neighbors.size (); 00141 helloPacket->setNeighborArraySize (initedNeighborCount); 00142 for (unsigned int k = 0; k < initedNeighborCount; k++) { 00143 helloPacket->setNeighbor (k, ULongFromIPv4Address (neighbors[k])); 00144 } 00145 00146 helloPacket->setPacketLength (0); // TODO: Calculate correct length 00147 helloPacket->setChecksum (0); // TODO: Calculate correct cheksum (16-bit one's complement of the entire packet) 00148 00149 parentArea->GetRouter ()->GetMessageHandler ()->SendPacket (helloPacket, destination, ifIndex, ttl); 00150 }
|
|
00153 { 00154 OSPFOptions options; 00155 OSPFLinkStateAcknowledgementPacket* lsAckPacket = new OSPFLinkStateAcknowledgementPacket; 00156 00157 lsAckPacket->setType (LinkStateAcknowledgementPacket); 00158 lsAckPacket->setRouterID (parentArea->GetRouter ()->GetRouterID ()); 00159 lsAckPacket->setAreaID (parentArea->GetAreaID ()); 00160 lsAckPacket->setAuthenticationType (authenticationType); 00161 for (int i = 0; i < 8; i++) { 00162 lsAckPacket->setAuthentication (i, authenticationKey.bytes[i]); 00163 } 00164 00165 lsAckPacket->setLsaHeadersArraySize (1); 00166 lsAckPacket->setLsaHeaders (0, *lsaHeader); 00167 00168 lsAckPacket->setPacketLength (0); // TODO: Calculate correct length 00169 lsAckPacket->setChecksum (0); // TODO: Calculate correct cheksum (16-bit one's complement of the entire packet) 00170 00171 int ttl = (interfaceType == OSPF::Interface::Virtual) ? VIRTUAL_LINK_TTL : 1; 00172 parentArea->GetRouter ()->GetMessageHandler ()->SendPacket (lsAckPacket, destination, ifIndex, ttl); 00173 }
|
|
00119 { acknowledgementDelay = delay; }
|
|
00133 { interfaceAddressRange = range; }
|
|
00145 { parentArea = area; }
|
|
00111 { areaID = areaId; }
|
|
00131 { authenticationKey = key; }
|
|
00129 { authenticationType = type; }
|
|
00123 { helloInterval = interval; }
|
|
00067 { 00068 ifIndex = index; 00069 if (interfaceType == OSPF::Interface::UnknownType) { 00070 InterfaceEntry* routingInterface = InterfaceTableAccess().get ()->interfaceAt (ifIndex); 00071 interfaceAddressRange.address = IPv4AddressFromAddressString (routingInterface->ipv4()->inetAddress ().str ().c_str ()); 00072 interfaceAddressRange.mask = IPv4AddressFromAddressString (routingInterface->ipv4()->netmask ().str ().c_str ()); 00073 mtu = routingInterface->mtu (); 00074 } 00075 }
|
|
00109 { mtu = ifMTU; }
|
|
00113 { interfaceOutputCost = cost; }
|
|
00125 { pollInterval = interval; }
|
|
00115 { retransmissionInterval = interval; }
|
|
00127 { routerDeadInterval = interval; }
|
|
00121 { routerPriority = priority; }
|
|
00117 { interfaceTransmissionDelay = delay; }
|
|
00105 { interfaceType = ifType; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|