INET Framework for OMNeT++/OMNEST
Public Member Functions | Protected Member Functions | List of all members
inet::ospfv3::Ospfv3InterfaceState Class Referenceabstract

#include <Ospfv3InterfaceState.h>

Inheritance diagram for inet::ospfv3::Ospfv3InterfaceState:
inet::ospfv3::Ospfv3InterfacePassive inet::ospfv3::Ospfv3InterfaceStateBackup inet::ospfv3::Ospfv3InterfaceStateDown inet::ospfv3::Ospfv3InterfaceStateDr inet::ospfv3::Ospfv3InterfaceStateDrOther inet::ospfv3::Ospfv3InterfaceStateLoopback inet::ospfv3::Ospfv3InterfaceStatePointToPoint inet::ospfv3::Ospfv3InterfaceStateWaiting

Public Member Functions

virtual void processEvent (Ospfv3Interface *interface, Ospfv3Interface::Ospfv3InterfaceEvent eventNum)=0
 
virtual Ospfv3Interface::Ospfv3InterfaceFaState getState () const =0
 
virtual ~Ospfv3InterfaceState ()
 
virtual std::string getInterfaceStateString () const =0
 

Protected Member Functions

void changeState (Ospfv3Interface *intf, Ospfv3InterfaceState *newState, Ospfv3InterfaceState *currentState)
 
void calculateDesignatedRouter (Ospfv3Interface *intf)
 

Constructor & Destructor Documentation

◆ ~Ospfv3InterfaceState()

virtual inet::ospfv3::Ospfv3InterfaceState::~Ospfv3InterfaceState ( )
inlinevirtual
16 {}

Member Function Documentation

◆ calculateDesignatedRouter()

void inet::ospfv3::Ospfv3InterfaceState::calculateDesignatedRouter ( Ospfv3Interface *  intf)
protected
203  {
204  Ipv4Address routerID = intf->getArea()->getInstance()->getProcess()->getRouterID();
205  Ipv4Address currentDesignatedRouter = intf->getDesignatedID();
206  Ipv4Address currentBackupRouter = intf->getBackupID();
207  EV_DEBUG << "Calculating the designated router, currentDesignated:" << currentDesignatedRouter << ", current backup: " << currentBackupRouter << "\n";
208 
209  unsigned int neighborCount = intf->getNeighborCount();
210  unsigned char repeatCount = 0;
211  unsigned int i;
212 
213  Ipv6Address declaredBackupIP;
214  int declaredBackupPriority;
215  Ipv4Address declaredBackupID;
216  bool backupDeclared;
217 
218  Ipv6Address declaredDesignatedRouterIP;
219  int declaredDesignatedRouterPriority;
220  Ipv4Address declaredDesignatedRouterID;
221  bool designatedRouterDeclared;
222 
223  do {
224  // calculating backup designated router
225  declaredBackupIP = Ipv6Address::UNSPECIFIED_ADDRESS;
226  declaredBackupPriority = 0;
227  declaredBackupID = NULL_IPV4ADDRESS;
228  backupDeclared = false;
229 
230  Ipv4Address highestRouter = NULL_IPV4ADDRESS;
231  L3Address highestRouterIP = Ipv6Address::UNSPECIFIED_ADDRESS;
232  int highestPriority = 0;
233 
234  for (i = 0; i < neighborCount; i++) {
235  Ospfv3Neighbor *neighbor = intf->getNeighbor(i);
236  int neighborPriority = neighbor->getNeighborPriority();
237 
238  if (neighbor->getState() < Ospfv3Neighbor::TWOWAY_STATE) {
239  continue;
240  }
241  if (neighborPriority == 0) {
242  continue;
243  }
244 
245  Ipv4Address neighborID = neighbor->getNeighborID();
246  Ipv4Address neighborsDesignatedRouterID = neighbor->getNeighborsDR();
247  Ipv4Address neighborsBackupDesignatedRouterID = neighbor->getNeighborsBackup();
248 
249 // EV_DEBUG << "Neighbors DR: " << neighborsDesignatedRouterID << ", neighbors backup: " << neighborsBackupDesignatedRouterID << "\n";
250  if (neighborsDesignatedRouterID != neighborID) {
251 // EV_DEBUG << "Router " << routerID << " trying backup on neighbor " << neighborID << "\n";
252  if (neighborsBackupDesignatedRouterID == neighborID) {
253  if ((neighborPriority > declaredBackupPriority) ||
254  ((neighborPriority == declaredBackupPriority) &&
255  (neighborID > declaredBackupID)))
256  {
257  declaredBackupID = neighborsBackupDesignatedRouterID;
258  declaredBackupPriority = neighborPriority;
259  declaredBackupIP = neighbor->getNeighborIP();
260  backupDeclared = true;
261  }
262  }
263  if (!backupDeclared) {
264  if ((neighborPriority > highestPriority) ||
265  ((neighborPriority == highestPriority) &&
266  (neighborID > highestRouter)))
267  {
268  highestRouter = neighborID;
269  highestRouterIP = neighbor->getNeighborIP();
270  highestPriority = neighborPriority;
271  }
272  }
273  }
274 // EV_DEBUG << "Router " << routerID << " declared backup is " << declaredBackupID << "\n";
275  }
276 
277  // also include the router itself in the calculations
278  if (intf->routerPriority > 0) {
279  if (currentDesignatedRouter != routerID) {
280  if (currentBackupRouter == routerID) {
281  if ((intf->routerPriority > declaredBackupPriority) ||
282  ((intf->routerPriority == declaredBackupPriority) &&
283  (routerID > declaredBackupID)))
284  {
285  declaredBackupID = routerID;
286  declaredBackupIP = intf->getInterfaceLLIP();
287  declaredBackupPriority = intf->getRouterPriority();
288  backupDeclared = true;
289  }
290  }
291  if (!backupDeclared) {
292  if ((intf->routerPriority > highestPriority) ||
293  ((intf->routerPriority == highestPriority) &&
294  (routerID > highestRouter)))
295  {
296  declaredBackupID = routerID;
297  declaredBackupIP = intf->getInterfaceLLIP();
298  declaredBackupPriority = intf->getRouterPriority();
299  backupDeclared = true;
300  }
301  else {
302  declaredBackupID = highestRouter;
303  declaredBackupPriority = highestPriority;
304  backupDeclared = true;
305  }
306  }
307  }
308  }
309 // EV_DEBUG << "Router " << routerID << " declared backup after backup round is " << declaredBackupID << "\n";
310  // calculating designated router
311  declaredDesignatedRouterID = NULL_IPV4ADDRESS;
312  declaredDesignatedRouterPriority = 0;
313  designatedRouterDeclared = false;
314 
315  for (i = 0; i < neighborCount; i++) {
316  Ospfv3Neighbor *neighbor = intf->getNeighbor(i);
317  unsigned short neighborPriority = neighbor->getNeighborPriority();
318 
319  if (neighbor->getState() < Ospfv3Neighbor::TWOWAY_STATE) {
320  continue;
321  }
322  if (neighborPriority == 0) {
323  continue;
324  }
325 
326  Ipv4Address neighborID = neighbor->getNeighborID();
327  Ipv4Address neighborsDesignatedRouterID = neighbor->getNeighborsDR();
328  Ipv4Address neighborsBackupDesignatedRouterID = neighbor->getNeighborsBackup();
329 
330  if (neighborsDesignatedRouterID == neighborID) {
331  if ((neighborPriority > declaredDesignatedRouterPriority) ||
332  ((neighborPriority == declaredDesignatedRouterPriority) &&
333  (neighborID > declaredDesignatedRouterID)))
334  {
335 // declaredDesignatedRouterID = neighborsDesignatedRouterID;
336  declaredDesignatedRouterPriority = neighborPriority;
337  declaredDesignatedRouterID = neighborID;
338  designatedRouterDeclared = true;
339  }
340  }
341  }
342 // EV_DEBUG << "Router " << routerID << " declared DR after neighbors is " << declaredDesignatedRouterID << "\n";
343  // also include the router itself in the calculations
344  if (intf->routerPriority > 0) {
345  if (currentDesignatedRouter == routerID) {
346  if ((intf->routerPriority > declaredDesignatedRouterPriority) ||
347  ((intf->routerPriority == declaredDesignatedRouterPriority) &&
348  (routerID > declaredDesignatedRouterID)))
349  {
350  declaredDesignatedRouterID = routerID;
351  declaredDesignatedRouterIP = intf->getInterfaceLLIP();
352  declaredDesignatedRouterPriority = intf->getRouterPriority();
353  designatedRouterDeclared = true;
354  }
355  }
356  }
357  if (!designatedRouterDeclared) {
358  declaredDesignatedRouterID = declaredBackupID;
359  declaredDesignatedRouterPriority = declaredBackupPriority;
360  designatedRouterDeclared = true;
361  }
362 // EV_DEBUG << "Router " << routerID << " declared DR after a round is " << declaredDesignatedRouterID << "\n";
363  // if the router is any kind of DR or is no longer one of them, then repeat
364  if (
365  (
366  (declaredDesignatedRouterID != NULL_IPV4ADDRESS) &&
367  (( //if this router is not the DR but it was before
368  (currentDesignatedRouter == routerID) &&
369  (declaredDesignatedRouterID != routerID)
370  ) ||
371  (//if this router was not the DR but now it is
372  (currentDesignatedRouter != routerID) &&
373  (declaredDesignatedRouterID == routerID)
374  ))
375  ) ||
376  (
377  (declaredBackupID != NULL_IPV4ADDRESS) &&
378  ((
379  (currentBackupRouter == routerID) &&
380  (declaredBackupID != routerID)
381  ) ||
382  (
383  (currentBackupRouter != routerID) &&
384  (declaredBackupID == routerID)
385  ))
386  )
387  )
388  {
389  currentDesignatedRouter = declaredDesignatedRouterID;
390  currentBackupRouter = declaredBackupID;
391  repeatCount++;
392  }
393  else {
394  repeatCount += 2;
395  }
396  } while (repeatCount < 2);
397 
398  Ipv4Address routersOldDesignatedRouterID = intf->getDesignatedID();
399  Ipv4Address routersOldBackupID = intf->getBackupID();
400 
401  intf->setDesignatedID(declaredDesignatedRouterID);
402  EV_DEBUG << "declaredDesignatedRouterID = " << declaredDesignatedRouterID << "\n";
403  EV_DEBUG << "declaredBackupID = " << declaredBackupID << "\n";
404  for (int g = 0; g < intf->getNeighborCount(); g++) {
405  EV_DEBUG << "@" << g << " - " << intf->getNeighbor(g)->getNeighborID() << " / " << intf->getNeighbor(g)->getNeighborInterfaceID() << "\n";
406  }
407 
408  Ospfv3Neighbor *DRneighbor = intf->getNeighborById(declaredDesignatedRouterID);
409  if (DRneighbor == nullptr) {
410  EV_DEBUG << "DRneighbor == nullptr\n";
411  intf->setDesignatedIntID(intf->getInterfaceId());
412  }
413  else {
414 // intf->setDesignatedIntID(DRneighbor->getInterface()->getInterfaceId());
415  intf->setDesignatedIntID(DRneighbor->getNeighborInterfaceID());
416  }
417  intf->setBackupID(declaredBackupID);
418 
419  bool wasBackupDesignatedRouter = (routersOldBackupID == routerID);
420  bool wasDesignatedRouter = (routersOldDesignatedRouterID == routerID);
421  bool wasOther = (intf->getState() == Ospfv3Interface::INTERFACE_STATE_DROTHER);
422  bool wasWaiting = (!wasBackupDesignatedRouter && !wasDesignatedRouter && !wasOther);
423  bool isBackupDesignatedRouter = (declaredBackupID == routerID);
424  bool isDesignatedRouter = (declaredDesignatedRouterID == routerID);
425  bool isOther = (!isBackupDesignatedRouter && !isDesignatedRouter);
426 
427  if (wasBackupDesignatedRouter) {
428  if (isDesignatedRouter) {
429  changeState(intf, new Ospfv3InterfaceStateDr, this);
430  }
431  if (isOther) {
432  changeState(intf, new Ospfv3InterfaceStateDrOther, this);
433  }
434  }
435  if (wasDesignatedRouter) {
436  if (isBackupDesignatedRouter) {
437  changeState(intf, new Ospfv3InterfaceStateBackup, this);
438  }
439  if (isOther) {
440  changeState(intf, new Ospfv3InterfaceStateDrOther, this);
441  }
442  if (isDesignatedRouter) { // for case that link between routers was disconnected and Router become DR again
443  changeState(intf, new Ospfv3InterfaceStateDr, this);
444  }
445  }
446  if (wasOther) {
447  if (isDesignatedRouter) {
448  changeState(intf, new Ospfv3InterfaceStateDr, this);
449  }
450  if (isBackupDesignatedRouter) {
451  changeState(intf, new Ospfv3InterfaceStateBackup, this);
452  }
453  }
454  if (wasWaiting) {
455  if (isDesignatedRouter) {
456  changeState(intf, new Ospfv3InterfaceStateDr, this);
457  }
458  if (isBackupDesignatedRouter) {
459  changeState(intf, new Ospfv3InterfaceStateBackup, this);
460  }
461  if (isOther) {
462  changeState(intf, new Ospfv3InterfaceStateDrOther, this);
463  }
464  }
465 
466  for (i = 0; i < neighborCount; i++) {
467  if ((intf->interfaceType == Ospfv3Interface::NBMA_TYPE) &&
468  ((!wasBackupDesignatedRouter && isBackupDesignatedRouter) ||
469  (!wasDesignatedRouter && isDesignatedRouter)))
470  {
471  if (intf->getNeighbor(i)->getNeighborPriority() == 0) {
472  intf->getNeighbor(i)->processEvent(Ospfv3Neighbor::START);
473  }
474  }
475  if ((declaredDesignatedRouterID != routersOldDesignatedRouterID) ||
476  (declaredBackupID != routersOldBackupID))
477  {
478  if (intf->getNeighbor(i)->getState() >= Ospfv3Neighbor::TWOWAY_STATE) {
479  intf->getNeighbor(i)->processEvent(Ospfv3Neighbor::IS_ADJACENCY_OK);
480  }
481  }
482  }
483 
484  if (intf->getDesignatedID() != intf->getArea()->getInstance()->getProcess()->getRouterID()) {
485  Ospfv3Neighbor *designated = intf->getNeighborById(intf->getDesignatedID());
486  if (designated != nullptr)
487  intf->setDesignatedIP(designated->getNeighborIP());
488  }
489  else
490  intf->setDesignatedIP(intf->getInterfaceLLIP());
491 
492  if (intf->getBackupID() != intf->getArea()->getInstance()->getProcess()->getRouterID()) {
493  Ospfv3Neighbor *backup = intf->getNeighborById(intf->getBackupID());
494  if (backup != nullptr)
495  intf->setBackupIP(backup->getNeighborIP());
496  }
497  else
498  intf->setBackupIP(intf->getInterfaceLLIP());
499 }

Referenced by inet::ospfv3::Ospfv3InterfaceStateDr::processEvent(), inet::ospfv3::Ospfv3InterfaceStateDrOther::processEvent(), inet::ospfv3::Ospfv3InterfaceStateWaiting::processEvent(), and inet::ospfv3::Ospfv3InterfaceStateBackup::processEvent().

◆ changeState()

void inet::ospfv3::Ospfv3InterfaceState::changeState ( Ospfv3Interface *  intf,
Ospfv3InterfaceState *  newState,
Ospfv3InterfaceState *  currentState 
)
protected
11 {
12  Ospfv3Interface::Ospfv3InterfaceFaState oldState = currentState->getState();
13  Ospfv3Interface::Ospfv3InterfaceFaState nextState = newState->getState();
14  Ospfv3Interface::Ospfv3InterfaceType intfType = interface->getType();
15  bool shouldRebuildRoutingTable = false;
16 
17  EV_DEBUG << "CHANGE STATE: " << interface->getArea()->getInstance()->getProcess()->getRouterID() << ", area " << interface->getArea()->getAreaID() << ", intf " << interface->getIntName() << ", curr st: " << currentState->getInterfaceStateString() << ", new st: " << newState->getInterfaceStateString() << "\n";
18 
19  interface->changeState(currentState, newState);
20 
21  // change of state -> new router LSA needs to be generated
22 
23  if ((oldState == Ospfv3Interface::INTERFACE_STATE_DOWN) ||
24  (nextState == Ospfv3Interface::INTERFACE_STATE_DOWN) ||
25  (oldState == Ospfv3Interface::INTERFACE_STATE_LOOPBACK) ||
26  (nextState == Ospfv3Interface::INTERFACE_STATE_LOOPBACK) ||
27  (oldState == Ospfv3Interface::INTERFACE_STATE_DESIGNATED) ||
28  (nextState == Ospfv3Interface::INTERFACE_STATE_DESIGNATED) ||
29 
30  ((intfType == Ospfv3Interface::POINTTOMULTIPOINT_TYPE) && ((oldState == Ospfv3Interface::INTERFACE_STATE_POINTTOPOINT) ||
31  (nextState == Ospfv3Interface::INTERFACE_STATE_POINTTOPOINT))) ||
32 
33  (((intfType == Ospfv3Interface::BROADCAST_TYPE) ||
34  (intfType == Ospfv3Interface::NBMA_TYPE)) && ( /*(oldState == Ospfv3Interface::INTERFACE_STATE_WAITING) ||*/
35  (nextState == Ospfv3Interface::INTERFACE_STATE_WAITING))))
36  {
37  LSAKeyType lsaKey;
38  lsaKey.LSType = Ospfv3LsaFunctionCode::ROUTER_LSA;
39  lsaKey.advertisingRouter = interface->getArea()->getInstance()->getProcess()->getRouterID();
40  lsaKey.linkStateID = interface->getArea()->getInstance()->getProcess()->getRouterID();
41 
42  RouterLSA *routerLSA = interface->getArea()->getRouterLSAbyKey(lsaKey);
43  if (routerLSA != nullptr) {
44  long sequenceNumber = routerLSA->getHeader().getLsaSequenceNumber();
45  if (sequenceNumber == MAX_SEQUENCE_NUMBER) {
46  routerLSA->getHeaderForUpdate().setLsaAge(MAX_AGE);
47  interface->getArea()->floodLSA(routerLSA);
48  routerLSA->incrementInstallTime();
49  }
50  else {
51  RouterLSA *newLSA = interface->getArea()->originateRouterLSA();
52 
53  newLSA->getHeaderForUpdate().setLsaSequenceNumber(sequenceNumber + 1);
54  shouldRebuildRoutingTable |= interface->getArea()->installRouterLSA(newLSA);
55  routerLSA = interface->getArea()->findRouterLSA(interface->getArea()->getInstance()->getProcess()->getRouterID());
56  interface->getArea()->setSpfTreeRoot(routerLSA);
57  interface->getArea()->floodLSA(newLSA);
58  delete newLSA;
59  }
60  }
61  else { // (lsa == nullptr) -> This must be the first time any interface is up...
62  RouterLSA *newLSA = interface->getArea()->originateRouterLSA();
63 
64  shouldRebuildRoutingTable |= interface->getArea()->installRouterLSA(newLSA);
65  if (shouldRebuildRoutingTable) {
66  routerLSA = interface->getArea()->findRouterLSA(interface->getArea()->getInstance()->getProcess()->getRouterID());
67  interface->getArea()->setSpfTreeRoot(routerLSA);
68  interface->getArea()->floodLSA(newLSA);
69  }
70  delete newLSA;
71  }
72  }
73  if (oldState == Ospfv3Interface::INTERFACE_STATE_WAITING) {
74  RouterLSA *routerLSA;
75  int routerLSAcount = interface->getArea()->getRouterLSACount();
76  int i = 0;
77  while (i < routerLSAcount) {
78  routerLSA = interface->getArea()->getRouterLSA(i);
79  const Ospfv3LsaHeader& header = routerLSA->getHeader();
80  if (header.getAdvertisingRouter() == interface->getArea()->getInstance()->getProcess()->getRouterID() &&
81  interface->getType() == Ospfv3Interface::BROADCAST_TYPE)
82  {
83  EV_DEBUG << "Changing state -> deleting the old router LSA\n";
84  interface->getArea()->deleteRouterLSA(i);
85  }
86 
87  if (interface->getArea()->getRouterLSACount() == routerLSAcount)
88  i++;
89  else { // some routerLSA was deleted
90  routerLSAcount = interface->getArea()->getRouterLSACount();
91  i = 0;
92  }
93  }
94 
95  EV_DEBUG << "Changing state -> new Router LSA\n";
96  RouterLSA *newLSA = interface->getArea()->originateRouterLSA();
97  if (newLSA != nullptr) {
98  if (interface->getArea()->installRouterLSA(newLSA)) {
99  routerLSA = interface->getArea()->findRouterLSA(interface->getArea()->getInstance()->getProcess()->getRouterID());
100  interface->getArea()->setSpfTreeRoot(routerLSA);
101  interface->getArea()->floodLSA(newLSA);
102  }
103  delete newLSA;
104  }
105  if (interface->getType() == Ospfv3Interface::POINTTOPOINT_TYPE || (interface->getArea()->hasAnyPassiveInterface())) {
106  Ospfv3IntraAreaPrefixLsa *prefLSA = interface->getArea()->originateIntraAreaPrefixLSA();
107  if (prefLSA != nullptr) {
108  if (interface->getArea()->installIntraAreaPrefixLSA(prefLSA)) {
109  interface->getArea()->floodLSA(prefLSA);
110  }
111  delete prefLSA;
112  }
113  }
114 
115  if (nextState == Ospfv3Interface::INTERFACE_STATE_BACKUP ||
116  nextState == Ospfv3Interface::INTERFACE_STATE_DESIGNATED ||
117  nextState == Ospfv3Interface::INTERFACE_STATE_DROTHER)
118  {
119  interface->setTransitNetInt(true); // this interface is in broadcast network
120 
121  // if router has any interface as Passive, create separate Intra-Area-Prefix-LSA for these interfaces
122  if (interface->getArea()->hasAnyPassiveInterface()) {
123  Ospfv3IntraAreaPrefixLsa *prefLSA = interface->getArea()->originateIntraAreaPrefixLSA();
124  if (prefLSA != nullptr) {
125  if (interface->getArea()->installIntraAreaPrefixLSA(prefLSA))
126  interface->getArea()->floodLSA(prefLSA);
127  delete prefLSA;
128  }
129  }
130  }
131  shouldRebuildRoutingTable = true;
132  }
133 
134  if (nextState == Ospfv3Interface::INTERFACE_STATE_DESIGNATED) {
135  NetworkLSA *newLSA = interface->getArea()->originateNetworkLSA(interface);
136  if (newLSA != nullptr) {
137  shouldRebuildRoutingTable |= interface->getArea()->installNetworkLSA(newLSA);
138  if (shouldRebuildRoutingTable) {
139  Ospfv3IntraAreaPrefixLsa *prefLSA = interface->getArea()->originateNetIntraAreaPrefixLSA(newLSA, interface, false);
140  if (prefLSA != nullptr) {
141  interface->getArea()->installIntraAreaPrefixLSA(prefLSA);
142  NetworkInterface *ie = interface->containingProcess->ift->getInterfaceById(interface->getInterfaceId());
143  auto ipv6int = ie->getProtocolDataForUpdate<Ipv6InterfaceData>();
144  ipv6int->joinMulticastGroup(Ipv6Address::ALL_OSPF_DESIGNATED_ROUTERS_MCAST);
145 
146  interface->getArea()->floodLSA(newLSA);
147  interface->getArea()->floodLSA(prefLSA);
148  }
149  delete prefLSA;
150  }
151  delete newLSA;
152  }
153  else {
154  NetworkLSA *networkLSA = interface->getArea()->findNetworkLSAByLSID(Ipv4Address(interface->getInterfaceId()));
155  if (networkLSA != nullptr) {
156  networkLSA->getHeaderForUpdate().setLsaAge(MAX_AGE);
157  interface->getArea()->floodLSA(networkLSA);
158  networkLSA->incrementInstallTime();
159  }
160  // here I am in state when interface comes to DR state but there is no neighbor on this iface.
161  // so new LSA type 9 need to be created
162 // if (interface->getArea()->getInstance()->getAreaCount() > 1) { //this is ABR
163 // interface->getArea()->originateInterAreaPrefixLSA(prefLSA, interface->getArea(), false);
164 // }
165  }
166  Ospfv3IntraAreaPrefixLsa *prefLSA = interface->getArea()->originateIntraAreaPrefixLSA();
167  if (prefLSA != nullptr) {
168  shouldRebuildRoutingTable |= interface->getArea()->installIntraAreaPrefixLSA(prefLSA);
169  interface->getArea()->floodLSA(prefLSA);
170  delete prefLSA;
171  }
172  }
173 
174  if (nextState == Ospfv3Interface::INTERFACE_STATE_BACKUP) {
175  NetworkInterface *ie = interface->containingProcess->ift->getInterfaceById(interface->getInterfaceId());
176  auto ipv6int = ie->getProtocolDataForUpdate<Ipv6InterfaceData>();
177  ipv6int->joinMulticastGroup(Ipv6Address::ALL_OSPF_DESIGNATED_ROUTERS_MCAST);
178  }
179 
180  if ((oldState == Ospfv3Interface::INTERFACE_STATE_DESIGNATED) && (nextState != Ospfv3Interface::INTERFACE_STATE_DESIGNATED)) {
181  NetworkLSA *networkLSA = interface->getArea()->findNetworkLSA(interface->getInterfaceId(), interface->getArea()->getInstance()->getProcess()->getRouterID());
182 //
183  if (networkLSA != nullptr) {
184  networkLSA->getHeaderForUpdate().setLsaAge(MAX_AGE);
185  interface->getArea()->floodLSA(networkLSA);
186  networkLSA->incrementInstallTime();
187  }
188  }
189 
190  if (shouldRebuildRoutingTable) {
191  interface->getArea()->getInstance()->getProcess()->rebuildRoutingTable();
192  }
193 
194  if ((oldState == Ospfv3Interface::INTERFACE_STATE_DESIGNATED || oldState == Ospfv3Interface::INTERFACE_STATE_BACKUP) &&
195  (nextState != Ospfv3Interface::INTERFACE_STATE_DESIGNATED && nextState != Ospfv3Interface::INTERFACE_STATE_BACKUP))
196  {
197  NetworkInterface *ie = interface->containingProcess->ift->getInterfaceById(interface->getInterfaceId());
198  auto ipv6int = ie->getProtocolDataForUpdate<Ipv6InterfaceData>();
199  ipv6int->leaveMulticastGroup(Ipv6Address::ALL_OSPF_DESIGNATED_ROUTERS_MCAST);
200  }
201 }

Referenced by calculateDesignatedRouter(), inet::ospfv3::Ospfv3InterfaceStateDown::processEvent(), inet::ospfv3::Ospfv3InterfacePassive::processEvent(), inet::ospfv3::Ospfv3InterfaceStateDr::processEvent(), inet::ospfv3::Ospfv3InterfaceStateDrOther::processEvent(), inet::ospfv3::Ospfv3InterfaceStateLoopback::processEvent(), inet::ospfv3::Ospfv3InterfaceStateWaiting::processEvent(), inet::ospfv3::Ospfv3InterfaceStatePointToPoint::processEvent(), and inet::ospfv3::Ospfv3InterfaceStateBackup::processEvent().

◆ getInterfaceStateString()

virtual std::string inet::ospfv3::Ospfv3InterfaceState::getInterfaceStateString ( ) const
pure virtual

Implemented in inet::ospfv3::Ospfv3InterfaceStateBackup, inet::ospfv3::Ospfv3InterfaceStatePointToPoint, inet::ospfv3::Ospfv3InterfaceStateLoopback, inet::ospfv3::Ospfv3InterfaceStateWaiting, inet::ospfv3::Ospfv3InterfacePassive, inet::ospfv3::Ospfv3InterfaceStateDr, inet::ospfv3::Ospfv3InterfaceStateDrOther, and inet::ospfv3::Ospfv3InterfaceStateDown.

Referenced by changeState(), inet::ospfv3::Ospfv3Interface::changeState(), and inet::ospfv3::Ospfv3Interface::processEvent().

◆ getState()

virtual Ospfv3Interface::Ospfv3InterfaceFaState inet::ospfv3::Ospfv3InterfaceState::getState ( ) const
pure virtual

Implemented in inet::ospfv3::Ospfv3InterfaceStateBackup, inet::ospfv3::Ospfv3InterfaceStatePointToPoint, inet::ospfv3::Ospfv3InterfaceStateLoopback, inet::ospfv3::Ospfv3InterfaceStateWaiting, inet::ospfv3::Ospfv3InterfacePassive, inet::ospfv3::Ospfv3InterfaceStateDr, inet::ospfv3::Ospfv3InterfaceStateDrOther, and inet::ospfv3::Ospfv3InterfaceStateDown.

Referenced by changeState(), and inet::ospfv3::Ospfv3Interface::getState().

◆ processEvent()

virtual void inet::ospfv3::Ospfv3InterfaceState::processEvent ( Ospfv3Interface *  interface,
Ospfv3Interface::Ospfv3InterfaceEvent  eventNum 
)
pure virtual

Implemented in inet::ospfv3::Ospfv3InterfaceStateBackup, inet::ospfv3::Ospfv3InterfaceStatePointToPoint, inet::ospfv3::Ospfv3InterfaceStateLoopback, inet::ospfv3::Ospfv3InterfaceStateWaiting, inet::ospfv3::Ospfv3InterfacePassive, inet::ospfv3::Ospfv3InterfaceStateDr, inet::ospfv3::Ospfv3InterfaceStateDrOther, and inet::ospfv3::Ospfv3InterfaceStateDown.

Referenced by inet::ospfv3::Ospfv3Interface::processEvent().

The documentation for this class was generated from the following files:
inet::ospfv3::Ospfv3Neighbor::TWOWAY_STATE
@ TWOWAY_STATE
Definition: Ospfv3Neighbor.h:46
inet::ospfv3::Ospfv3Interface::NBMA_TYPE
@ NBMA_TYPE
Definition: Ospfv3Interface.h:54
inet::ospfv3::Ospfv3Interface::BROADCAST_TYPE
@ BROADCAST_TYPE
Definition: Ospfv3Interface.h:53
MAX_SEQUENCE_NUMBER
#define MAX_SEQUENCE_NUMBER
Definition: Ospfv2Common.h:34
inet::ospfv3::Ospfv3Interface::INTERFACE_STATE_DROTHER
@ INTERFACE_STATE_DROTHER
Definition: Ospfv3Interface.h:31
inet::ospfv3::Ospfv3Interface::Ospfv3InterfaceType
Ospfv3InterfaceType
Definition: Ospfv3Interface.h:50
inet::ospfv3::Ospfv3Interface::INTERFACE_STATE_WAITING
@ INTERFACE_STATE_WAITING
Definition: Ospfv3Interface.h:29
inet::ospfv3::Ospfv3Interface::INTERFACE_STATE_LOOPBACK
@ INTERFACE_STATE_LOOPBACK
Definition: Ospfv3Interface.h:28
MAX_AGE
#define MAX_AGE
Definition: Ospfv2Common.h:27
inet::ospfv3::Ospfv3Interface::Ospfv3InterfaceFaState
Ospfv3InterfaceFaState
Definition: Ospfv3Interface.h:26
inet::units::units::g
milli< kg >::type g
Definition: Units.h:1071
inet::ospfv3::Ospfv3Interface::INTERFACE_STATE_DOWN
@ INTERFACE_STATE_DOWN
Definition: Ospfv3Interface.h:27
inet::Ipv6Address::UNSPECIFIED_ADDRESS
static const Ipv6Address UNSPECIFIED_ADDRESS
The unspecified address.
Definition: Ipv6Address.h:54
inet::ospfv3::Ospfv3InterfaceState::changeState
void changeState(Ospfv3Interface *intf, Ospfv3InterfaceState *newState, Ospfv3InterfaceState *currentState)
Definition: Ospfv3InterfaceState.cc:10
inet::ospfv3::Ospfv3Interface::POINTTOMULTIPOINT_TYPE
@ POINTTOMULTIPOINT_TYPE
Definition: Ospfv3Interface.h:55
inet::ospfv3::Ospfv3Interface::POINTTOPOINT_TYPE
@ POINTTOPOINT_TYPE
Definition: Ospfv3Interface.h:52
inet::ospfv3::Ospfv3Neighbor::START
@ START
Definition: Ospfv3Neighbor.h:24
inet::ospfv3::Ospfv3Neighbor::IS_ADJACENCY_OK
@ IS_ADJACENCY_OK
Definition: Ospfv3Neighbor.h:30
inet::ospfv3::Ospfv3Interface::INTERFACE_STATE_POINTTOPOINT
@ INTERFACE_STATE_POINTTOPOINT
Definition: Ospfv3Interface.h:30
inet::ospfv3::ROUTER_LSA
@ ROUTER_LSA
Definition: Ospfv3Packet_m.h:396
inet::ospfv3::NULL_IPV4ADDRESS
const Ipv4Address NULL_IPV4ADDRESS(0, 0, 0, 0)
inet::Ipv6Address::ALL_OSPF_DESIGNATED_ROUTERS_MCAST
static const Ipv6Address ALL_OSPF_DESIGNATED_ROUTERS_MCAST
OSPF designated routers.
Definition: Ipv6Address.h:87
inet::ospfv3::Ospfv3Interface::INTERFACE_STATE_BACKUP
@ INTERFACE_STATE_BACKUP
Definition: Ospfv3Interface.h:32
inet::ospfv3::Ospfv3Interface::INTERFACE_STATE_DESIGNATED
@ INTERFACE_STATE_DESIGNATED
Definition: Ospfv3Interface.h:33