rstp_prt.c
Go to the documentation of this file.
1 /**
2  * @file rstp_prt.c
3  * @brief Port Role Transition state machine (PRT)
4  *
5  * @section License
6  *
7  * SPDX-License-Identifier: GPL-2.0-or-later
8  *
9  * Copyright (C) 2019-2024 Oryx Embedded SARL. All rights reserved.
10  *
11  * This file is part of CycloneSTP Open.
12  *
13  * This program is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU General Public License
15  * as published by the Free Software Foundation; either version 2
16  * of the License, or (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software Foundation,
25  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
26  *
27  * @author Oryx Embedded SARL (www.oryx-embedded.com)
28  * @version 2.4.0
29  **/
30 
31 //Switch to the appropriate trace level
32 #define TRACE_LEVEL RSTP_TRACE_LEVEL
33 
34 //Dependencies
35 #include "rstp/rstp.h"
36 #include "rstp/rstp_fsm.h"
37 #include "rstp/rstp_prt.h"
38 #include "rstp/rstp_procedures.h"
39 #include "rstp/rstp_conditions.h"
40 #include "rstp/rstp_misc.h"
41 #include "debug.h"
42 
43 //Check TCP/IP stack configuration
44 #if (RSTP_SUPPORT == ENABLED)
45 
46 //PRT state machine's states
48 {
49  {RSTP_PRT_STATE_INIT_PORT, "INIT_PORT"},
50  {RSTP_PRT_STATE_DISABLE_PORT, "DISABLE_PORT"},
51  {RSTP_PRT_STATE_DISABLED_PORT, "DISABLED_PORT"},
52  {RSTP_PRT_STATE_ROOT_PROPOSED, "ROOT_PROPOSED"},
53  {RSTP_PRT_STATE_ROOT_AGREED, "ROOT_AGREED"},
54  {RSTP_PRT_STATE_REROOT, "REROOT"},
55  {RSTP_PRT_STATE_ROOT_FORWARD, "ROOT_FORWARD"},
56  {RSTP_PRT_STATE_ROOT_LEARN, "ROOT_LEARN"},
57  {RSTP_PRT_STATE_REROOTED, "REROOTED"},
58  {RSTP_PRT_STATE_ROOT_PORT, "ROOT_PORT"},
59  {RSTP_PRT_STATE_DESIGNATED_PROPOSE, "DESIGNATED_PROPOSE"},
60  {RSTP_PRT_STATE_DESIGNATED_SYNCED, "DESIGNATED_SYNCED"},
61  {RSTP_PRT_STATE_DESIGNATED_RETIRED, "DESIGNATED_RETIRED"},
62  {RSTP_PRT_STATE_DESIGNATED_FORWARD, "DESIGNATED_FORWARD"},
63  {RSTP_PRT_STATE_DESIGNATED_LEARN, "DESIGNATED_LEARN"},
64  {RSTP_PRT_STATE_DESIGNATED_DISCARD, "DESIGNATED_DISCARD"},
65  {RSTP_PRT_STATE_DESIGNATED_PORT, "DESIGNATED_PORT"},
66  {RSTP_PRT_STATE_ALTERNATE_PROPOSED, "ALTERNATE_PROPOSED"},
67  {RSTP_PRT_STATE_ALTERNATE_AGREED, "ALTERNATE_AGREED"},
68  {RSTP_PRT_STATE_BLOCK_PORT, "BLOCK_PORT"},
69  {RSTP_PRT_STATE_BACKUP_PORT, "BACKUP_PORT"},
70  {RSTP_PRT_STATE_ALTERNATE_PORT, "ALTERNATE_PORT"}
71 };
72 
73 
74 /**
75  * @brief PRT state machine initialization
76  * @param[in] port Pointer to the bridge port context
77  **/
78 
80 {
81  //Enter initial state
83 }
84 
85 
86 /**
87  * @brief PRT state machine implementation
88  * @param[in] port Pointer to the bridge port context
89  **/
90 
92 {
93  //The selected port role is updated by Port Role Selection state machine
94  if(port->role != port->selectedRole)
95  {
96  //Check the newly computed role for the port
97  switch(port->selectedRole)
98  {
100  //Switch to Disabled port role
102  break;
103 
104  case STP_PORT_ROLE_ROOT:
105  //Switch to Root port role
107  break;
108 
110  //Switch to Designated port role
112  break;
113 
116  //Switch to Alternate or Backup port role
118  break;
119 
120  default:
121  //Just for sanity
122  rstpFsmError(port->context);
123  break;
124  }
125  }
126  else
127  {
128  //Check current port role
129  switch(port->role)
130  {
132  //Process the states associated with the Disabled port role
134  break;
135 
136  case STP_PORT_ROLE_ROOT:
137  //Process the states associated with the Root port role
139  break;
140 
142  //Process the states associated with the Designated port role
144  break;
145 
148  //Process the states associated with the Alternate or Backup port role
150  break;
151 
152  default:
153  //Just for sanity
154  rstpFsmError(port->context);
155  break;
156  }
157  }
158 }
159 
160 
161 /**
162  * @brief PRT state machine implementation (Disabled port role)
163  * @param[in] port Pointer to the bridge port context
164  **/
165 
167 {
168  //All conditions for the current state are evaluated continuously until one
169  //of the conditions is met (refer to IEEE Std 802.1D-2004, section 17.16)
170  switch(port->prtState)
171  {
172  //INIT_PORT state?
174  //Unconditional transition (UCT) to DISABLE_PORT state
176  break;
177 
178  //DISABLE_PORT state?
180  //All transitions, except UCT, are qualified by the following condition
181  if(port->selected && !port->updtInfo)
182  {
183  //Check the learning and forwarding flags
184  if(!port->learning && !port->forwarding)
185  {
186  //Switch to DISABLED_PORT state
188  }
189  }
190 
191  break;
192 
193  //DISABLED_PORT state?
195  //All transitions, except UCT, are qualified by the following condition
196  if(port->selected && !port->updtInfo)
197  {
198  //Evaluate conditions for the current state
199  if(port->fdWhile != rstpMaxAge(port) || port->sync || port->reRoot ||
200  !port->synced)
201  {
202  //Switch to DISABLED_PORT state
204  }
205  }
206 
207  break;
208 
209  //Invalid state?
210  default:
211  //Just for sanity
212  rstpFsmError(port->context);
213  break;
214  }
215 }
216 
217 
218 /**
219  * @brief Update PRT state machine state (Disabled port role)
220  * @param[in] port Pointer to the bridge port context
221  * @param[in] newState New state to switch to
222  **/
223 
225 {
226  //Dump the state transition
227  TRACE_VERBOSE("Port %" PRIu8 ": PRT state machine %s -> %s\r\n",
228  port->portIndex,
231 
232  //Switch to the new state
233  port->prtState = newState;
234 
235  //On entry to a state, the procedures defined for the state are executed
236  //exactly once (refer to IEEE Std 802.1D-2004, section 17.16)
237  switch(port->prtState)
238  {
239  //INIT_PORT state?
241  //Initialize variables
243  port->learn = FALSE;
244  port->forward = FALSE;
245  port->synced = FALSE;
246  port->sync = TRUE;
247  port->reRoot = TRUE;
248  port->rrWhile = rstpFwdDelay(port);
249  port->fdWhile = rstpMaxAge(port);
250  port->rbWhile = 0;
251  break;
252 
253  //DISABLE_PORT state?
255  //Update port role
256  port->role = port->selectedRole;
257  port->learn = FALSE;
258  port->forward = FALSE;
259  break;
260 
261  //DISABLED_PORT state?
263  //Reload the Forward Delay timer
264  port->fdWhile = rstpMaxAge(port);
265  port->synced = TRUE;
266  port->rrWhile = 0;
267  port->sync = FALSE;
268  port->reRoot = FALSE;
269  break;
270 
271  //Invalid state?
272  default:
273  //Just for sanity
274  break;
275  }
276 
277  //The RSTP state machine is busy
278  port->context->busy = TRUE;
279 }
280 
281 
282 /**
283  * @brief PRT state machine implementation (Root port role)
284  * @param[in] port Pointer to the bridge port context
285  **/
286 
288 {
289  //All conditions for the current state are evaluated continuously until one
290  //of the conditions is met (refer to IEEE Std 802.1D-2004, section 17.16)
291  switch(port->prtState)
292  {
293  //ROOT_PROPOSED, ROOT_AGREED, REROOT, ROOT_FORWARD, ROOT_LEARN or REROOTED
294  //state?
301  //Unconditional transition (UCT) to ROOT_PORT state
303  break;
304 
305  //ROOT_PORT state?
307  //All transitions, except UCT, are qualified by the following condition
308  if(port->selected && !port->updtInfo)
309  {
310  //Evaluate conditions for the current state
311  if(port->proposed && !port->agree)
312  {
313  //Switch to ROOT_PROPOSED state
315  }
316  else if((rstpAllSynced(port->context) && !port->agree) ||
317  (port->proposed && port->agree))
318  {
319  //Switch to ROOT_AGREED state
321  }
322  else if(!port->forward && !port->reRoot)
323  {
324  //Switch to REROOT state
326  }
327  else if(port->rrWhile != rstpFwdDelay(port))
328  {
329  //Switch to ROOT_PORT state
331  }
332  else if(port->reRoot && port->forward)
333  {
334  //Switch to REROOTED state
336  }
337  else if(port->fdWhile == 0 || (rstpReRooted(port) &&
338  port->rbWhile == 0 && rstpVersion(port->context)))
339  {
340  //The Root port can transition to Learning and to Forwarding
341  if(!port->learn)
342  {
343  //Switch to ROOT_LEARN state
345  }
346  else if(port->learn && !port->forward)
347  {
348  //Switch to ROOT_FORWARD state
350  }
351  else
352  {
353  //Just for sanity
354  }
355  }
356  else
357  {
358  //Just for sanity
359  }
360  }
361 
362  break;
363 
364  //Invalid state?
365  default:
366  //Just for sanity
367  rstpFsmError(port->context);
368  break;
369  }
370 }
371 
372 
373 /**
374  * @brief Update PRT state machine state (Root port role)
375  * @param[in] port Pointer to the bridge port context
376  * @param[in] newState New state to switch to
377  **/
378 
380 {
381  //Dump the state transition
382  TRACE_VERBOSE("Port %" PRIu8 ": PRT state machine %s -> %s\r\n",
383  port->portIndex,
386 
387  //Switch to the new state
388  port->prtState = newState;
389 
390  //On entry to a state, the procedures defined for the state are executed
391  //exactly once (refer to IEEE Std 802.1D-2004, section 17.16)
392  switch(port->prtState)
393  {
394  //ROOT_PROPOSED state?
396  //Proposal
397  rstpSetSyncTree(port->context);
398  port->proposed = FALSE;
399  break;
400 
401  //ROOT_AGREED state?
403  //Agreement
404  port->proposed = FALSE;
405  port->sync = FALSE;
406  port->agree = TRUE;
407  port->newInfo = TRUE;
408  break;
409 
410  //REROOT state?
412  //Set reRoot for all bridge ports
413  rstpSetReRootTree(port->context);
414  break;
415 
416  //ROOT_FORWARD state?
418  //The forward variable is used by this state machine to request the
419  //Port State Transitions machine to change the port state
420  port->fdWhile = 0;
421  port->forward = TRUE;
422  break;
423 
424  //ROOT_LEARN state?
426  //The learn variable is used by this state machine to request the
427  //Port State Transitions machine to change the port state
428  port->fdWhile= rstpForwardDelay(port);
429  port->learn = TRUE;
430  break;
431 
432  //REROOTED state?
434  //Clear the reRoot variable
435  port->reRoot = FALSE;
436  break;
437 
438  //ROOT_PORT state?
440  //Update port role
441  port->role = STP_PORT_ROLE_ROOT;
442  port->rrWhile = rstpFwdDelay(port);
443  break;
444 
445  //Invalid state?
446  default:
447  //Just for sanity
448  break;
449  }
450 
451  //The RSTP state machine is busy
452  port->context->busy = TRUE;
453 }
454 
455 
456 /**
457  * @brief PRT state machine implementation (Designated port role)
458  * @param[in] port Pointer to the bridge port context
459  **/
460 
462 {
463  //All conditions for the current state are evaluated continuously until one
464  //of the conditions is met (refer to IEEE Std 802.1D-2004, section 17.16)
465  switch(port->prtState)
466  {
467  //DESIGNATED_PROPOSE, DESIGNATED_SYNCED, DESIGNATED_RETIRED,
468  //DESIGNATED_FORWARD, DESIGNATED_LEARN or DESIGNATED_DISCARD state?
475  //Unconditional transition (UCT) to DESIGNATED_PORT state
477  break;
478 
479  //DESIGNATED_PORT state?
481  //All transitions, except UCT, are qualified by the following condition
482  if(port->selected && !port->updtInfo)
483  {
484  //Evaluate conditions for the current state
485  if(!port->forward && !port->agreed && !port->proposing &&
486  !port->operEdge)
487  {
488  //Switch to DESIGNATED_PROPOSE state
490  }
491  else if((!port->learning && !port->forwarding && !port->synced) ||
492  (port->agreed && !port->synced) || (port->operEdge && !port->synced) ||
493  (port->sync && port->synced))
494  {
495  //Switch to DESIGNATED_SYNCED state
497  }
498  else if(port->rrWhile == 0 && port->reRoot)
499  {
500  //Switch to DESIGNATED_RETIRED state
502  }
503  else if(((port->sync && !port->synced) || (port->reRoot && port->rrWhile != 0) ||
504  port->disputed) && !port->operEdge && (port->learn || port->forward))
505  {
506  //Switch to DESIGNATED_DISCARD state
508  }
509  else if((port->fdWhile == 0 || port->agreed || port->operEdge) &&
510  (port->rrWhile == 0 || !port->reRoot) && !port->sync)
511  {
512  //The Designated port can transition to Learning and to Forwarding
513  if(!port->learn)
514  {
515  //Switch to DESIGNATED_LEARN state
517  }
518  else if(port->learn && !port->forward)
519  {
520  //Switch to DESIGNATED_FORWARD state
522  }
523  else
524  {
525  //Just for sanity
526  }
527  }
528  else
529  {
530  //Just for sanity
531  }
532  }
533 
534  break;
535 
536  //Invalid state?
537  default:
538  //Just for sanity
539  rstpFsmError(port->context);
540  break;
541  }
542 }
543 
544 
545 /**
546  * @brief Update PRT state machine state (Designated port role)
547  * @param[in] port Pointer to the bridge port context
548  * @param[in] newState New state to switch to
549  **/
550 
552 {
553  //Dump the state transition
554  TRACE_VERBOSE("Port %" PRIu8 ": PRT state machine %s -> %s\r\n",
555  port->portIndex,
558 
559  //Switch to the new state
560  port->prtState = newState;
561 
562  //On entry to a state, the procedures defined for the state are executed
563  //exactly once (refer to IEEE Std 802.1D-2004, section 17.16)
564  switch(port->prtState)
565  {
566  //DESIGNATED_PROPOSE state?
568  //When a Designated port is in a Discarding or Learning state (and only
569  //in this case), it sets the proposal bit on the BPDUs it sends out
570  port->proposing = TRUE;
571  port->edgeDelayWhile = rstpEdgeDelay(port);
572  port->newInfo = TRUE;
573  break;
574 
575  //DESIGNATED_SYNCED state?
577  //Synchronize the port state with spanning tree information
578  port->rrWhile = 0;
579  port->synced = TRUE;
580  port->sync = FALSE;
581  break;
582 
583  //DESIGNATED_RETIRED state?
585  //Clear the reRoot variable
586  port->reRoot = FALSE;
587  break;
588 
589  //DESIGNATED_FORWARD state?
591  //The forward variable is used by this state machine to request the
592  //Port State Transitions machine to change the port state
593  port->forward = TRUE;
594  port->fdWhile = 0;
595  port->agreed = port->sendRstp;
596  break;
597 
598  //DESIGNATED_LEARN state?
600  //The learn variable is used by this state machine to request the
601  //Port State Transitions machine to change the port state
602  port->learn = TRUE;
603  port->fdWhile= rstpForwardDelay(port);
604  break;
605 
606  //DESIGNATED_DISCARD state?
608  //Transition the Designated port to Discarding
609  port->learn = FALSE;
610  port->forward = FALSE;
611  port->disputed = FALSE;
612  port->fdWhile = rstpForwardDelay(port);
613  break;
614 
615  //DESIGNATED_PORT state?
617  //Update port role
619  break;
620 
621  //Invalid state?
622  default:
623  //Just for sanity
624  break;
625  }
626 
627  //The RSTP state machine is busy
628  port->context->busy = TRUE;
629 }
630 
631 
632 /**
633  * @brief PRT state machine implementation (Alternate or Backup port role)
634  * @param[in] port Pointer to the bridge port context
635  **/
636 
638 {
639  //All conditions for the current state are evaluated continuously until one
640  //of the conditions is met (refer to IEEE Std 802.1D-2004, section 17.16)
641  switch(port->prtState)
642  {
643  //ALTERNATE_PROPOSED, ALTERNATE_AGREED or BACKUP_PORT state?
647  //Unconditional transition (UCT) to ALTERNATE_PORT state
649  break;
650 
651  //BLOCK_PORT state?
653  //All transitions, except UCT, are qualified by the following condition
654  if(port->selected && !port->updtInfo)
655  {
656  //Check the learning and forwarding flags
657  if(!port->learning && !port->forwarding)
658  {
659  //Switch to ALTERNATE_PORT state
661  }
662  }
663 
664  break;
665 
666  //ALTERNATE_PORT state?
668  //All transitions, except UCT, are qualified by the following condition
669  if(port->selected && !port->updtInfo)
670  {
671  //Evaluate conditions for the current state
672  if(port->proposed && !port->agree)
673  {
674  //Switch to ALTERNATE_PROPOSED state
676  }
677  else if((rstpAllSynced(port->context) && !port->agree) ||
678  (port->proposed && port->agree))
679  {
680  //Switch to ALTERNATE_AGREED state
682  }
683  else if(port->rbWhile != (2 * rstpHelloTime(port)) &&
684  port->role == STP_PORT_ROLE_BACKUP)
685  {
686  //Switch to BACKUP_PORT state
688  }
689  else if(port->fdWhile != rstpForwardDelay(port) || port->sync ||
690  port->reRoot || !port->synced)
691  {
692  //Switch to ALTERNATE_PORT state
694  }
695  else
696  {
697  //Just for sanity
698  }
699  }
700 
701  break;
702 
703  //Invalid state?
704  default:
705  //Just for sanity
706  rstpFsmError(port->context);
707  break;
708  }
709 }
710 
711 
712 /**
713  * @brief Update PRT state machine state (Alternate or Backup port role)
714  * @param[in] port Pointer to the bridge port context
715  * @param[in] newState New state to switch to
716  **/
717 
719 {
720  //Dump the state transition
721  TRACE_VERBOSE("Port %" PRIu8 ": PRT state machine %s -> %s\r\n",
722  port->portIndex,
725 
726  //Switch to the new state
727  port->prtState = newState;
728 
729  //On entry to a state, the procedures defined for the state are executed
730  //exactly once (refer to IEEE Std 802.1D-2004, section 17.16)
731  switch(port->prtState)
732  {
733  //ALTERNATE_PROPOSED state?
735  //Proposal
736  rstpSetSyncTree(port->context);
737  port->proposed = FALSE;
738  break;
739 
740  //ALTERNATE_AGREED state?
742  //Agreement
743  port->proposed = FALSE;
744  port->agree = TRUE;
745  port->newInfo = TRUE;
746  break;
747 
748  //BLOCK_PORT state?
750  //Update port role
751  port->role = port->selectedRole;
752  port->learn = FALSE;
753  port->forward = FALSE;
754  break;
755 
756  //BACKUP_PORT state?
758  //The Recent Backup timer is maintained at its initial value, twice
759  //HelloTime, while the port is a Backup port
760  port->rbWhile = 2 * rstpHelloTime(port);
761  break;
762 
763  //ALTERNATE_PORT state?
765  //Errata (refer to IEEE Std 802.1Q-2018, section 13.37)
766  port->fdWhile = rstpForwardDelay(port);
767 
768  port->synced = TRUE;
769  port->rrWhile = 0;
770  port->sync = FALSE;
771  port->reRoot = FALSE;
772  break;
773 
774  //Invalid state?
775  default:
776  //Just for sanity
777  break;
778  }
779 
780  //The RSTP state machine is busy
781  port->context->busy = TRUE;
782 }
783 
784 #endif
Debugging facilities.
#define TRACE_VERBOSE(...)
Definition: debug.h:124
uint16_t port
Definition: dns_common.h:267
#define arraysize(a)
Definition: os_port.h:71
#define TRUE
Definition: os_port.h:50
#define FALSE
Definition: os_port.h:46
RSTP (Rapid Spanning Tree Protocol)
#define RstpBridgePort
Definition: rstp.h:40
uint_t rstpHelloTime(RstpBridgePort *port)
HelloTime variable evaluation (17.20.7)
bool_t rstpVersion(RstpBridgeContext *context)
rstpVersion condition (17.20.11)
uint_t rstpMaxAge(RstpBridgePort *port)
MaxAge variable evaluation (17.20.8)
uint_t rstpForwardDelay(RstpBridgePort *port)
forwardDelay variable evaluation (17.20.5)
uint_t rstpFwdDelay(RstpBridgePort *port)
FwdDelay variable evaluation (17.20.6)
bool_t rstpReRooted(RstpBridgePort *port)
reRooted condition (17.20.10)
bool_t rstpAllSynced(RstpBridgeContext *context)
allSynced condition (17.20.3)
uint_t rstpEdgeDelay(RstpBridgePort *port)
EdgeDelay variable evaluation (17.20.4)
RSTP state machine conditions.
void rstpFsmError(RstpBridgeContext *context)
RSTP state machine error handler.
Definition: rstp_fsm.c:226
Rapid Spanning Tree state machines.
const char_t * rstpGetParamName(uint_t value, const RstpParamName *paramList, size_t paramListLen)
Convert a parameter to string representation.
Definition: rstp_misc.c:883
RSTP helper functions.
void rstpSetSyncTree(RstpBridgeContext *context)
Set sync for all ports of the bridge (17.21.14)
void rstpSetReRootTree(RstpBridgeContext *context)
Set reRoot for all ports of the bridge (17.21.15)
RSTP state machine procedures.
void rstpPrtDisabledPortChangeState(RstpBridgePort *port, RstpPrtState newState)
Update PRT state machine state (Disabled port role)
Definition: rstp_prt.c:224
void rstpPrtRootPortChangeState(RstpBridgePort *port, RstpPrtState newState)
Update PRT state machine state (Root port role)
Definition: rstp_prt.c:379
void rstpPrtRootPortFsm(RstpBridgePort *port)
PRT state machine implementation (Root port role)
Definition: rstp_prt.c:287
void rstpPrtDisabledPortFsm(RstpBridgePort *port)
PRT state machine implementation (Disabled port role)
Definition: rstp_prt.c:166
const RstpParamName rstpPrtStates[]
Definition: rstp_prt.c:47
void rstpPrtFsm(RstpBridgePort *port)
PRT state machine implementation.
Definition: rstp_prt.c:91
void rstpPrtDesignatedPortChangeState(RstpBridgePort *port, RstpPrtState newState)
Update PRT state machine state (Designated port role)
Definition: rstp_prt.c:551
void rstpPrtInit(RstpBridgePort *port)
PRT state machine initialization.
Definition: rstp_prt.c:79
void rstpPrtAlternatePortChangeState(RstpBridgePort *port, RstpPrtState newState)
Update PRT state machine state (Alternate or Backup port role)
Definition: rstp_prt.c:718
void rstpPrtDesignatedPortFsm(RstpBridgePort *port)
PRT state machine implementation (Designated port role)
Definition: rstp_prt.c:461
void rstpPrtAlternatePortFsm(RstpBridgePort *port)
PRT state machine implementation (Alternate or Backup port role)
Definition: rstp_prt.c:637
Port Role Transition state machine (PRT)
RstpPrtState
Port Role Transition machine states.
Definition: rstp_prt.h:48
@ RSTP_PRT_STATE_DESIGNATED_RETIRED
Definition: rstp_prt.h:61
@ RSTP_PRT_STATE_BACKUP_PORT
Definition: rstp_prt.h:69
@ RSTP_PRT_STATE_DISABLED_PORT
Definition: rstp_prt.h:51
@ RSTP_PRT_STATE_ROOT_AGREED
Definition: rstp_prt.h:53
@ RSTP_PRT_STATE_BLOCK_PORT
Definition: rstp_prt.h:68
@ RSTP_PRT_STATE_ROOT_PROPOSED
Definition: rstp_prt.h:52
@ RSTP_PRT_STATE_ROOT_FORWARD
Definition: rstp_prt.h:55
@ RSTP_PRT_STATE_REROOT
Definition: rstp_prt.h:54
@ RSTP_PRT_STATE_ALTERNATE_PROPOSED
Definition: rstp_prt.h:66
@ RSTP_PRT_STATE_DISABLE_PORT
Definition: rstp_prt.h:50
@ RSTP_PRT_STATE_INIT_PORT
Definition: rstp_prt.h:49
@ RSTP_PRT_STATE_ALTERNATE_AGREED
Definition: rstp_prt.h:67
@ RSTP_PRT_STATE_DESIGNATED_PROPOSE
Definition: rstp_prt.h:59
@ RSTP_PRT_STATE_DESIGNATED_PORT
Definition: rstp_prt.h:65
@ RSTP_PRT_STATE_DESIGNATED_LEARN
Definition: rstp_prt.h:63
@ RSTP_PRT_STATE_DESIGNATED_DISCARD
Definition: rstp_prt.h:64
@ RSTP_PRT_STATE_ROOT_PORT
Definition: rstp_prt.h:58
@ RSTP_PRT_STATE_ALTERNATE_PORT
Definition: rstp_prt.h:70
@ RSTP_PRT_STATE_DESIGNATED_FORWARD
Definition: rstp_prt.h:62
@ RSTP_PRT_STATE_REROOTED
Definition: rstp_prt.h:57
@ RSTP_PRT_STATE_DESIGNATED_SYNCED
Definition: rstp_prt.h:60
@ RSTP_PRT_STATE_ROOT_LEARN
Definition: rstp_prt.h:56
@ STP_PORT_ROLE_BACKUP
Definition: stp_common.h:128
@ STP_PORT_ROLE_ALTERNATE
Definition: stp_common.h:127
@ STP_PORT_ROLE_ROOT
Definition: stp_common.h:125
@ STP_PORT_ROLE_DESIGNATED
Definition: stp_common.h:126
@ STP_PORT_ROLE_DISABLED
Definition: stp_common.h:124
Parameter value/name binding.
Definition: rstp_misc.h:48