1 /************************************************************************
2  * RSTP library - Rapid Spanning Tree (802.1t, 802.1w)
3  * Copyright (C) 2001-2003 Optical Access
4  * Author: Alex Rozin
5  *
6  * This file is part of RSTP library.
7  *
8  * RSTP library is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU Lesser General Public License as published by the
10  * Free Software Foundation; version 2.1
11  *
12  * RSTP library is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public License
18  * along with RSTP library; see the file COPYING.  If not, write to the Free
19  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20  * 02111-1307, USA.
21  **********************************************************************/
22 
23 /* Port Role Selection state machine : 17.22 */
24 
25 #include "base.h"
26 #include "stpm.h"
27 #include "stp_vectors.h"
28 
29 #define STATES { \
30   CHOOSE(INIT_BRIDGE),      \
31   CHOOSE(ROLE_SELECTION)   \
32 }
33 
34 #define GET_STATE_NAME STP_rolesel_get_state_name
35 #include "choose.h"
36 
37 #if 0
38 void stp_dbg_break_point (PORT_T * port, STPM_T* stpm)
39 {
40 }
41 #endif
42 
43 static Bool
44 _is_backup_port (PORT_T* port, STPM_T* this)
45 {
46   if (!STP_VECT_compare_bridge_id
47       (&port->portPrio.design_bridge, &this->BrId)) {
48 #if 0 /* def STP_DBG */
49     if (port->info->debug) {
50       STP_VECT_br_id_print ("portPrio.design_bridge",
51                             &port->portPrio.design_bridge, True);
52       STP_VECT_br_id_print ("            this->BrId",
53                             &this->BrId, True);
54     }
55     stp_dbg_break_point (port, this);
56 #endif
57     return True;
58   } else {
59     return False;
60   }
61 }
62 
63 /* ARGSUSED */
64 static void
65 setRoleSelected (char* reason, STPM_T* stpm, PORT_T* port,
66                 PORT_ROLE_T newRole)
67 {
68 #ifdef STP_DBG
69   char* new_role_name;
70 #endif
71 
72   port->selectedRole = newRole;
73 
74   if (newRole == port->role)
75     return;
76 
77   switch (newRole) {
78     case DisabledPort:
79 #ifdef STP_DBG
80       new_role_name = "Disabled";
81 #endif
82       break;
83     case AlternatePort:
84 #ifdef STP_DBG
85       new_role_name = "Alternate";
86 #endif
87       break;
88     case BackupPort:
89 #ifdef STP_DBG
90       new_role_name = "Backup";
91 #endif
92       break;
93     case RootPort:
94 #ifdef STP_DBG
95       new_role_name = "Root";
96 #endif
97       break;
98     case DesignatedPort:
99 #ifdef STP_DBG
100       new_role_name = "Designated";
101 #endif
102       break;
103     case NonStpPort:
104 #ifdef STP_DBG
105       new_role_name = "NonStp";
106 #endif
107       port->role = newRole;
108       break;
109     default:
110 #ifdef STP_DBG
111       stp_trace ("%s-%s:port %s => Unknown (%d ?)",
112                  reason, stpm->name, port->port_name, (int) newRole);
113 #else
114       abort();
115 #endif
116       return;
117   }
118 
119 #ifdef STP_DBG
120   if (port->roletrns->debug)
121     stp_trace ("%s(%s-%s) => %s",
122                reason, stpm->name, port->port_name, new_role_name);
123 #endif
124 }
125 
126 static void
127 updtRoleDisableBridge (STPM_T* this)
128 {               /* 17.10.20 */
129   register PORT_T *port;
130 
131   for (port = this->ports; port; port = port->next) {
132     port->selectedRole = DisabledPort;
133   }
134 }
135 
136 static void
137 clearReselectBridge (STPM_T* this)
138 {               /* 17.19.1 */
139   register PORT_T *port;
140 
141   for (port = this->ports; port; port = port->next) {
142     port->reselect = False;
143   }
144 }
145 
146 static void
147 updtRootPrio (STATE_MACH_T* this)
148 {
149   PRIO_VECTOR_T rootPathPrio;   /* 17.4.2.2 */
150   register PORT_T *port;
151   register STPM_T *stpm;
152   register unsigned int dm;
153 
154   stpm = this->owner.stpm;
155 
156   for (port = stpm->ports; port; port = port->next) {
157     if (port->admin_non_stp) {
158       continue;
159     }
160 
161     if (Disabled == port->infoIs)
162       continue;
163     if (Aged == port->infoIs)
164       continue;
165     if (Mine == port->infoIs) {
166 #if 0 /* def STP_DBG */
167       stp_dbg_break_point (port); /* for debugger break point */
168 #endif
169       continue;
170     }
171 
172     STP_VECT_copy (&rootPathPrio, &port->portPrio);
173     rootPathPrio.root_path_cost += port->operPCost;
174 
175     if (STP_VECT_compare_vector (&rootPathPrio, &stpm->rootPrio) < 0) {
176       STP_VECT_copy (&stpm->rootPrio, &rootPathPrio);
177       STP_copy_times (&stpm->rootTimes, &port->portTimes);
178       dm = (8 +  stpm->rootTimes.MaxAge) / 16;
179       if (!dm)
180         dm = 1;
181       stpm->rootTimes.MessageAge += dm;
182 #ifdef STP_DBG
183       if (port->roletrns->debug)
184           stp_trace ("updtRootPrio: dm=%d rootTimes.MessageAge=%d on port %s",
185                  (int) dm, (int) stpm->rootTimes.MessageAge,
186                  port->port_name);
187 #endif
188     }
189   }
190 }
191 
192 static void
193 updtRolesBridge (STATE_MACH_T* this)
194 {               /* 17.19.21 */
195   register PORT_T* port;
196   register STPM_T* stpm;
197 #ifdef STP_DBG
198   PORT_ID old_root_port; /* for tracing of root port changing */
199 #endif
200 
201   stpm = this->owner.stpm;
202 #ifdef STP_DBG
203   old_root_port = stpm->rootPortId;
204 #endif
205 
206   STP_VECT_create (&stpm->rootPrio, &stpm->BrId, 0, &stpm->BrId, 0, 0);
207   STP_copy_times (&stpm->rootTimes, &stpm->BrTimes);
208   stpm->rootPortId = 0;
209 
210   updtRootPrio (this);
211 
212   for (port = stpm->ports; port; port = port->next) {
213     if (port->admin_non_stp) {
214       continue;
215     }
216     STP_VECT_create (&port->designPrio,
217              &stpm->rootPrio.root_bridge,
218              stpm->rootPrio.root_path_cost,
219              &stpm->BrId, port->port_id, port->port_id);
220     STP_copy_times (&port->designTimes, &stpm->rootTimes);
221 
222 #if 0
223 #ifdef STP_DBG
224     if (port->roletrns->debug) {
225       STP_VECT_br_id_print ("ch:designPrio.design_bridge",
226                             &port->designPrio.design_bridge, True);
227     }
228 #endif
229 #endif
230   }
231 
232   stpm->rootPortId = stpm->rootPrio.bridge_port;
233 
234 #ifdef STP_DBG
235   if (old_root_port != stpm->rootPortId) {
236     if (! stpm->rootPortId) {
237       stp_trace ("bridge %s became root", stpm->name);
238     } else {
239       stp_trace ("bridge %s new root port: %s",
240         stpm->name,
241         STP_stpm_get_port_name_by_id (stpm, stpm->rootPortId));
242     }
243   }
244 #endif
245 
246   for (port = stpm->ports; port; port = port->next) {
247     if (port->admin_non_stp) {
248       setRoleSelected ("Non", stpm, port, NonStpPort);
249       port->forward = port->learn = True;
250       continue;
251     }
252 
253     switch (port->infoIs) {
254       case Disabled:
255         setRoleSelected ("Dis", stpm, port, DisabledPort);
256         break;
257       case Aged:
258         setRoleSelected ("Age", stpm, port, DesignatedPort);
259         port->updtInfo = True;
260         break;
261       case Mine:
262         setRoleSelected ("Mine", stpm, port, DesignatedPort);
263         if (0 != STP_VECT_compare_vector (&port->portPrio,
264                       &port->designPrio) ||
265             0 != STP_compare_times (&port->portTimes,
266                   &port->designTimes)) {
267             port->updtInfo = True;
268         }
269         break;
270       case Received:
271         if (stpm->rootPortId == port->port_id) {
272           setRoleSelected ("Rec", stpm, port, RootPort);
273         } else if (STP_VECT_compare_vector (&port->designPrio, &port->portPrio) < 0) {
274           /* Note: this important piece has been inserted after
275            * discussion with Mick Sieman and reading 802.1y Z1 */
276           setRoleSelected ("Rec", stpm, port, DesignatedPort);
277           port->updtInfo = True;
278           break;
279         } else {
280           if (_is_backup_port (port, stpm)) {
281             setRoleSelected ("rec", stpm, port, BackupPort);
282           } else {
283             setRoleSelected ("rec", stpm, port, AlternatePort);
284           }
285         }
286         port->updtInfo = False;
287         break;
288       default:
289         stp_trace ("undef infoIs=%d", (int) port->infoIs);
290         break;
291     }
292   }
293 
294 }
295 
296 
297 static Bool
298 setSelectedBridge (STPM_T* this)
299 {
300   register PORT_T* port;
301 
302   for (port = this->ports; port; port = port->next) {
303     if (port->reselect) {
304 #ifdef STP_DBG
305       stp_trace ("setSelectedBridge: TRUE=reselect on port %s", port->port_name);
306 #endif
307       return False;
308     }
309   }
310 
311   for (port = this->ports; port; port = port->next) {
312     port->selected = True;
313   }
314 
315   return True;
316 }
317 
318 void
319 STP_rolesel_enter_state (STATE_MACH_T* this)
320 {
321   STPM_T* stpm;
322 
323   stpm = this->owner.stpm;
324 
325   switch (this->State) {
326     case BEGIN:
327     case INIT_BRIDGE:
328       updtRoleDisableBridge (stpm);
329       break;
330     case ROLE_SELECTION:
331       clearReselectBridge (stpm);
332       updtRolesBridge (this);
333       (void) setSelectedBridge (stpm);
334       break;
335   }
336 }
337 
338 Bool
339 STP_rolesel_check_conditions (STATE_MACH_T* s)
340 {
341   STPM_T* stpm;
342   register PORT_T* port;
343 
344   /*
345    * This doesn't look right.  Why should we hop state twice in a single check
346    * condition call?  It means we can never perform the enter-state action for
347    * INIT_BRIDGE.
348    */
349 #ifdef carlsonj_removed
350   if (BEGIN == s->State) {
351     (void) STP_hop_2_state (s, INIT_BRIDGE);
352   }
353 #endif
354 
355   switch (s->State) {
356     case BEGIN:
357       return STP_hop_2_state (s, INIT_BRIDGE);
358     case INIT_BRIDGE:
359       return STP_hop_2_state (s, ROLE_SELECTION);
360     case ROLE_SELECTION:
361       stpm = s->owner.stpm;
362       for (port = stpm->ports; port; port = port->next) {
363         if (port->reselect) {
364           /* stp_trace ("reselect on port %s", port->port_name); */
365           return STP_hop_2_state (s, ROLE_SELECTION);
366         }
367       }
368       break;
369   }
370 
371   return False;
372 }
373 
374 void
375 STP_rolesel_update_stpm (STPM_T* this)
376 {
377   register PORT_T* port;
378   PRIO_VECTOR_T rootPathPrio;   /* 17.4.2.2 */
379 
380   stp_trace ("%s", "??? STP_rolesel_update_stpm ???");
381   STP_VECT_create (&rootPathPrio, &this->BrId, 0, &this->BrId, 0, 0);
382 
383   if (!this->rootPortId ||
384       STP_VECT_compare_vector (&rootPathPrio, &this->rootPrio) < 0) {
385     STP_VECT_copy (&this->rootPrio, &rootPathPrio);
386   }
387 
388   for (port = this->ports; port; port = port->next) {
389     STP_VECT_create (&port->designPrio,
390              &this->rootPrio.root_bridge,
391              this->rootPrio.root_path_cost,
392              &this->BrId, port->port_id, port->port_id);
393     if (Received != port->infoIs || this->rootPortId == port->port_id) {
394       STP_VECT_copy (&port->portPrio, &port->designPrio);
395     }
396     port->reselect = True;
397     port->selected = False;
398   }
399 }
400 
401