[people/ms/rstp.git] / rstplib / topoch.c

/************************************************************************ 
 * RSTP library - Rapid Spanning Tree (802.1t, 802.1w) 
 * Copyright (C) 2001-2003 Optical Access 
 * Author: Alex Rozin 
 * 
 * This file is part of RSTP library. 
 * 
 * RSTP library is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by the 
 * Free Software Foundation; version 2.1 
 * 
 * RSTP library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser 
 * General Public License for more details. 
 * 
 * You should have received a copy of the GNU Lesser General Public License 
 * along with RSTP library; see the file COPYING.  If not, write to the Free 
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 
 * 02111-1307, USA. 
 **********************************************************************/

/* Topolgy Change state machine : 17.25 */
  
#include "base.h"
#include "stpm.h"
#include "stp_to.h" /* for STP_OUT_flush_lt */
  
#define STATES { \
  CHOOSE(INIT),             \
  CHOOSE(INACTIVE),         \
  CHOOSE(TCACTIVE),         \
  CHOOSE(DETECTED),         \
  CHOOSE(NOTIFIED_TC),          \
  CHOOSE(PROPAGATING),          \
  CHOOSE(ACKNOWLEDGED),         \
  CHOOSE(NOTIFIED_TCN),         \
}

#define GET_STATE_NAME STP_topoch_get_state_name
#include "choose.h"

/* We can flush learned fdb by port, so set this in stpm.c and topoch.c  */
/* This doesn't seem to solve the topology change problems. Don't use it yet */
//#define STRONGLY_SPEC_802_1W

#ifndef STRONGLY_SPEC_802_1W
/* 
 * In many kinds of hardware the function
 * STP_OUT_flush_lt is a) is very hard and b) cannot
 * delete learning emtries per port. The alternate
 * method may be used: we don't care operEdge flag here,
 * but clean learning table once for TopologyChange
 * for all ports, except the received port. I am ready to discuss :(
 * See below word STRONGLY_SPEC_802_1W
 */
#else
static Bool
flush (STATE_MACH_T *this, char* reason) /* 17.19.9 */
{
  register PORT_T* port = this->owner.port;
  Bool bret;

  if (port->operEdge) return True;
  if (this->debug) {
    stp_trace("%s (%s, %s, %s, '%s')",
        "flush", port->port_name, port->owner->name,
        "this port",
        reason);
  }

  bret = STP_OUT_flush_lt (port->port_index, port->owner->vlan_id,
                           LT_FLASH_ONLY_THE_PORT, reason);
  return bret;
}
#endif

static void
setTcPropBridge (STATE_MACH_T* this, char* reason) /* 17.19.14 */
{
  register PORT_T* port = this->owner.port;
  register PORT_T* tmp;

  for (tmp = port->owner->ports; tmp; tmp = tmp->next) {
    if (tmp->port_index != port->port_index)
      tmp->tcProp = True;
  }

#ifndef STRONGLY_SPEC_802_1W
#ifdef STP_DBG
  if (this->debug) {
    stp_trace("%s (%s, %s, %s, '%s')",
        "clearFDB", port->port_name, port->owner->name,
        "other ports", reason);
  }
#endif

  STP_OUT_flush_lt (port->port_index, port->owner->vlan_id,
                    LT_FLASH_ALL_PORTS_EXCLUDE_THIS, reason);
#endif
}

static unsigned int
newTcWhile (STATE_MACH_T* this) /* 17.19.7 */
{
  register PORT_T* port = this->owner.port;

  if (port->sendRSTP && port->operPointToPointMac) {
    return 2 * port->owner->rootTimes.HelloTime;
  }
#ifdef ORIG
  return port->owner->rootTimes.MaxAge;
#else
  return port->owner->rootTimes.MaxAge + port->owner->rootTimes.ForwardDelay;
#endif
}

void
STP_topoch_enter_state (STATE_MACH_T* this)
{
  register PORT_T*      port = this->owner.port;

  switch (this->State) {
    case BEGIN:
    case INIT:
#ifdef STRONGLY_SPEC_802_1W
      flush (this, "topoch INIT");
#endif
      port->tcWhile = 0;
      port->tc =
      port->tcProp =
      port->tcAck = False;
      break;
    case INACTIVE:
      port->rcvdTc =
      port->rcvdTcn =
      port->rcvdTcAck = port->tc = port->tcProp = False;
      break;
    case TCACTIVE:
      break;
    case DETECTED:
      port->tcWhile = newTcWhile (this);
#ifdef STP_DBG
  if (this->debug) 
    stp_trace("DETECTED: tcWhile=%d on port %s", 
        port->tcWhile, port->port_name);
#endif
      setTcPropBridge (this, "DETECTED");
      port->tc = False;  
      break;
    case NOTIFIED_TC:
      port->rcvdTcn = port->rcvdTc = False;
      if (port->role == DesignatedPort) {
        port->tcAck = True;
      }
      setTcPropBridge (this, "NOTIFIED_TC");
      break;
    case PROPAGATING:
      port->tcWhile = newTcWhile (this);
#ifdef STP_DBG
  if (this->debug) 
    stp_trace("PROPAGATING: tcWhile=%d on port %s", 
        port->tcWhile, port->port_name);
#endif
#ifdef STRONGLY_SPEC_802_1W
      flush (this, "topoch PROPAGATING");
#endif
      port->tcProp = False;
      break;
    case ACKNOWLEDGED:
      port->tcWhile = 0;
#ifdef STP_DBG
  if (this->debug) 
    stp_trace("ACKNOWLEDGED: tcWhile=%d on port %s", 
        port->tcWhile, port->port_name);
#endif
      port->rcvdTcAck = False;
      break;
    case NOTIFIED_TCN:
      port->tcWhile = newTcWhile (this);
#ifdef STP_DBG
  if (this->debug) 
    stp_trace("NOTIFIED_TCN: tcWhile=%d on port %s", 
        port->tcWhile, port->port_name);
#endif
      break;
  };
}

Bool
STP_topoch_check_conditions (STATE_MACH_T* this)
{
  register PORT_T*      port = this->owner.port;

  if (BEGIN == this->State) {
    return STP_hop_2_state (this, INIT);
  }

  switch (this->State) {
    case INIT:
      return STP_hop_2_state (this, INACTIVE);
    case INACTIVE:
      if (port->role == RootPort || port->role == DesignatedPort)
        return STP_hop_2_state (this, TCACTIVE);
      if (port->rcvdTc || port->rcvdTcn || port->rcvdTcAck ||
          port->tc || port->tcProp)
        return STP_hop_2_state (this, INACTIVE);
      break;
    case TCACTIVE:
      if (port->role != RootPort && (port->role != DesignatedPort))
        return STP_hop_2_state (this, INIT);
      if (port->tc)
        return STP_hop_2_state (this, DETECTED);
      if (port->rcvdTcn)
        return STP_hop_2_state (this, NOTIFIED_TCN);
      if (port->rcvdTc)
        return STP_hop_2_state (this, NOTIFIED_TC);
      if (port->tcProp && !port->operEdge)
        return STP_hop_2_state (this, PROPAGATING);
      if (port->rcvdTcAck)
        return STP_hop_2_state (this, ACKNOWLEDGED);
      break;
    case DETECTED:
      return STP_hop_2_state (this, TCACTIVE);
    case NOTIFIED_TC:
      return STP_hop_2_state (this, TCACTIVE);
    case PROPAGATING:
      return STP_hop_2_state (this, TCACTIVE);
    case ACKNOWLEDGED:
      return STP_hop_2_state (this, TCACTIVE);
    case NOTIFIED_TCN:
      return STP_hop_2_state (this, NOTIFIED_TC);
  };
  return False;
}
Commit	Line	Data
ad02a0eb SH	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	/* Topolgy Change state machine : 17.25 */
	24
	25	#include "base.h"
	26	#include "stpm.h"
	27	#include "stp_to.h" /* for STP_OUT_flush_lt */
	28
	29	#define STATES { \
	30	CHOOSE(INIT), \
	31	CHOOSE(INACTIVE), \
	32	CHOOSE(TCACTIVE), \
	33	CHOOSE(DETECTED), \
	34	CHOOSE(NOTIFIED_TC), \
	35	CHOOSE(PROPAGATING), \
	36	CHOOSE(ACKNOWLEDGED), \
	37	CHOOSE(NOTIFIED_TCN), \
	38	}
	39
	40	#define GET_STATE_NAME STP_topoch_get_state_name
	41	#include "choose.h"
	42
	43	/* We can flush learned fdb by port, so set this in stpm.c and topoch.c */
	44	/* This doesn't seem to solve the topology change problems. Don't use it yet */
	45	//#define STRONGLY_SPEC_802_1W
	46
	47	#ifndef STRONGLY_SPEC_802_1W
	48	/*
	49	* In many kinds of hardware the function
	50	* STP_OUT_flush_lt is a) is very hard and b) cannot
	51	* delete learning emtries per port. The alternate
	52	* method may be used: we don't care operEdge flag here,
	53	* but clean learning table once for TopologyChange
	54	* for all ports, except the received port. I am ready to discuss :(
	55	* See below word STRONGLY_SPEC_802_1W
	56	*/
	57	#else
	58	static Bool
	59	flush (STATE_MACH_T this, char reason) /* 17.19.9 */
	60	{
	61	register PORT_T* port = this->owner.port;
	62	Bool bret;
	63
	64	if (port->operEdge) return True;
65	if (this->debug) {
66	stp_trace("%s (%s, %s, %s, '%s')",
67	"flush", port->port_name, port->owner->name,
68	"this port",
69	reason);
70	}
71
72	bret = STP_OUT_flush_lt (port->port_index, port->owner->vlan_id,
73	LT_FLASH_ONLY_THE_PORT, reason);
74	return bret;
75	}
76	#endif
77
78	static void
79	setTcPropBridge (STATE_MACH_T* this, char* reason) /* 17.19.14 */
80	{
81	register PORT_T* port = this->owner.port;
82	register PORT_T* tmp;
83
84	for (tmp = port->owner->ports; tmp; tmp = tmp->next) {
85	if (tmp->port_index != port->port_index)
86	tmp->tcProp = True;
87	}
88
89	#ifndef STRONGLY_SPEC_802_1W
90	#ifdef STP_DBG
91	if (this->debug) {
92	stp_trace("%s (%s, %s, %s, '%s')",
93	"clearFDB", port->port_name, port->owner->name,
94	"other ports", reason);
95	}
96	#endif
97
98	STP_OUT_flush_lt (port->port_index, port->owner->vlan_id,
99	LT_FLASH_ALL_PORTS_EXCLUDE_THIS, reason);
100	#endif
101	}
102
103	static unsigned int
104	newTcWhile (STATE_MACH_T* this) /* 17.19.7 */
105	{
106	register PORT_T* port = this->owner.port;
107
108	if (port->sendRSTP && port->operPointToPointMac) {
109	return 2 * port->owner->rootTimes.HelloTime;
110	}
111	#ifdef ORIG
112	return port->owner->rootTimes.MaxAge;
113	#else
114	return port->owner->rootTimes.MaxAge + port->owner->rootTimes.ForwardDelay;
115	#endif
116	}
117
118	void
119	STP_topoch_enter_state (STATE_MACH_T* this)
120	{
121	register PORT_T* port = this->owner.port;
122
123	switch (this->State) {
124	case BEGIN:
125	case INIT:
126	#ifdef STRONGLY_SPEC_802_1W
127	flush (this, "topoch INIT");
128	#endif
129	port->tcWhile = 0;
130	port->tc =
131	port->tcProp =
132	port->tcAck = False;
133	break;
134	case INACTIVE:
135	port->rcvdTc =
136	port->rcvdTcn =
137	port->rcvdTcAck = port->tc = port->tcProp = False;
138	break;
139	case TCACTIVE:
140	break;
141	case DETECTED:
142	port->tcWhile = newTcWhile (this);
143	#ifdef STP_DBG
144	if (this->debug)
145	stp_trace("DETECTED: tcWhile=%d on port %s",
146	port->tcWhile, port->port_name);
147	#endif
148	setTcPropBridge (this, "DETECTED");
149	port->tc = False;
150	break;
151	case NOTIFIED_TC:
152	port->rcvdTcn = port->rcvdTc = False;
153	if (port->role == DesignatedPort) {
154	port->tcAck = True;
155	}
156	setTcPropBridge (this, "NOTIFIED_TC");
157	break;
158	case PROPAGATING:
159	port->tcWhile = newTcWhile (this);
160	#ifdef STP_DBG
161	if (this->debug)
162	stp_trace("PROPAGATING: tcWhile=%d on port %s",
163	port->tcWhile, port->port_name);
164	#endif
165	#ifdef STRONGLY_SPEC_802_1W
166	flush (this, "topoch PROPAGATING");
167	#endif
168	port->tcProp = False;
169	break;
170	case ACKNOWLEDGED:
171	port->tcWhile = 0;
172	#ifdef STP_DBG
173	if (this->debug)
174	stp_trace("ACKNOWLEDGED: tcWhile=%d on port %s",
175	port->tcWhile, port->port_name);
176	#endif
177	port->rcvdTcAck = False;
178	break;
179	case NOTIFIED_TCN:
180	port->tcWhile = newTcWhile (this);
181	#ifdef STP_DBG
182	if (this->debug)
183	stp_trace("NOTIFIED_TCN: tcWhile=%d on port %s",
184	port->tcWhile, port->port_name);
185	#endif
186	break;
187	};
188	}
189
190	Bool
191	STP_topoch_check_conditions (STATE_MACH_T* this)
192	{
193	register PORT_T* port = this->owner.port;
194
195	if (BEGIN == this->State) {
196	return STP_hop_2_state (this, INIT);
197	}
198
199	switch (this->State) {
200	case INIT:
201	return STP_hop_2_state (this, INACTIVE);
202	case INACTIVE:
203	if (port->role == RootPort \|\| port->role == DesignatedPort)
204	return STP_hop_2_state (this, TCACTIVE);
205	if (port->rcvdTc \|\| port->rcvdTcn \|\| port->rcvdTcAck \|\|
206	port->tc \|\| port->tcProp)
207	return STP_hop_2_state (this, INACTIVE);
208	break;
209	case TCACTIVE:
210	if (port->role != RootPort && (port->role != DesignatedPort))
211	return STP_hop_2_state (this, INIT);
212	if (port->tc)
213	return STP_hop_2_state (this, DETECTED);
214	if (port->rcvdTcn)
215	return STP_hop_2_state (this, NOTIFIED_TCN);
216	if (port->rcvdTc)
217	return STP_hop_2_state (this, NOTIFIED_TC);
218	if (port->tcProp && !port->operEdge)
219	return STP_hop_2_state (this, PROPAGATING);
220	if (port->rcvdTcAck)
221	return STP_hop_2_state (this, ACKNOWLEDGED);
222	break;
223	case DETECTED:
224	return STP_hop_2_state (this, TCACTIVE);
225	case NOTIFIED_TC:
226	return STP_hop_2_state (this, TCACTIVE);
227	case PROPAGATING:
228	return STP_hop_2_state (this, TCACTIVE);
229	case ACKNOWLEDGED:
230	return STP_hop_2_state (this, TCACTIVE);
231	case NOTIFIED_TCN:
232	return STP_hop_2_state (this, NOTIFIED_TC);
233	};
234	return False;
235	}
236