roletrns.c.bak

rstp for switch in vxworks

/************************************************************************ 
 * 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. 
 **********************************************************************/

/* Port Role Transitions state machine : 17.23 */

#include "base.h"

#include "stpm.h"

#define STATES { \
   CHOOSE(INIT_PORT),       \
   CHOOSE(BLOCK_PORT),      \
   CHOOSE(BLOCKED_PORT),    \
   CHOOSE(BACKUP_PORT),     \
   CHOOSE(ROOT_PROPOSED),   \
   CHOOSE(ROOT_AGREED),     \
   CHOOSE(REROOT),      \
   CHOOSE(ROOT_PORT),       \
   CHOOSE(REROOTED),        \
   CHOOSE(ROOT_LEARN),      \
   CHOOSE(ROOT_FORWARD),    \
   CHOOSE(DESIGNATED_PROPOSE),  \
   CHOOSE(DESIGNATED_SYNCED),   \
   CHOOSE(DESIGNATED_RETIRED),  \
   CHOOSE(DESIGNATED_PORT), \
   CHOOSE(DESIGNATED_LISTEN),   \
   CHOOSE(DESIGNATED_LEARN),    \
   CHOOSE(DESIGNATED_FORWARD),  \
}


#define INIT_PORT             2
#define BLOCK_PORT            3
#define BLOCKED_PORT          4
#define BACKUP_PORT           5
#define ROOT_PROPOSED         6
#define ROOT_AGREED           7
#define REROOT                8
#define ROOT_PORT             9
#define REROOTED              10
#define ROOT_LEARN            11
#define ROOT_FORWARD          12
#define DESIGNATED_PROPOSE    13
#define DESIGNATED_SYNCED     14
#define DESIGNATED_RETIRED    15
#define DESIGNATED_PORT       16
#define DESIGNATED_LISTEN     17
#define DESIGNATED_LEARN      18
#define DESIGNATED_FORWARD    19







#define GET_STATE_NAME STP_roletrns_get_state_name
#include "choose.h"

/************************************************************************************
  函数名称:
  输入参数:
  输出参数:
  功能描述:  将所有端口的sync设置为True,迫使所有的非edge端口状态
                           恢复到discarding.
  返回值:
  备注           : 图17－16 ROOT_PROPOSED
  作者           :
  日期           :
  ************************************************************************************/

static void setSyncBridge (STATE_MACH_T * this)
{
	register struct net_bridge_port  *port;

        register struct net_bridge_port  *port1;
	register struct net_bridge *testbr;

 	port1 = this->owner.port   ;    
	testbr = port1->br;

	for ((port = this->owner.port)->br->port_list; port; port = port->next)
	{
		port->sync = True;	/* in ROOT_PROPOSED (setSyncBridge) */
	}
}

/************************************************************************************
  函数名称:
  输入参数:
  输出参数:
  功能描述:  设置桥的所有端口的reRoot为真
  返回值:
  备注           : 图17－16 REROOT
  作者           :
  日期           :
  ************************************************************************************/
static void setReRootBridge (STATE_MACH_T * this)
{
	register struct net_bridge_port *port;
        register struct net_bridge_port *port1;
        register struct net_bridge *testbr;
		
	port1 = this->owner.port;
	testbr = port1->br;

/*	for (port = this->owner.port->owner->ports; port; port = port->next)*/
	for (port = testbr->port_list;port;port = port->next)
	{
		port->reRoot = True;	/* In setReRootBridge */
	}
}

/************************************************************************************
  函数名称:
  输入参数:
  输出参数:
  功能描述:   判断是否所有端口的synced都为真
  返回值:        True: 所有端口的synced为真
                            False:至少有一个端口的synced不为真
  备注           : 
  作者           :
  日期           :
  ************************************************************************************/
static Bool compute_all_synced (struct net_bridge_port * this)
{
	register struct net_bridge_port  *port;

	for (port = this->br->port_list; port; port = port->next)
	{
		if (port->port_id == this->port_id)
			continue;
		if (!port->synced)
		{
			return False;
		}
	}

	return True;
}

/************************************************************************************
  函数名称:
  输入参数:
  输出参数:
  功能描述: 判断是否有端口曾经是root port。 
  返回值:      True:  所有端口的rrWhile都为0
                          False: 至少有一个端口的rrWhile不为0
  备注           : 
  作者           :
  日期           :
  ************************************************************************************/
static Bool compute_re_rooted (struct net_bridge_port * this)
{
	register struct net_bridge_port *port;

	for (port = this->br->port_list; port; port = port->next)
	{
		if (port->port_id == this->port_id)
			continue;
		if (port->rrWhile)
		{
			return False;
		}
	}
	return True;
}

/************************************************************************************
  函数名称:
  输入参数:
  输出参数:
  功能描述:  Port Role Transitions 状态函数
  返回值:
  备注:17.23
  作者:
  日期:
  ************************************************************************************/

void STP_roletrns_enter_state (STATE_MACH_T * this)
{
	register struct net_bridge_port  *port = this->owner.port;
	register struct net_bridge*stpm;

	stpm = port->br;

	switch (this->State)
	{
		case BEGIN:
		case INIT_PORT:
			mn_fd_printf(cl_serv_console_fd,"roletrn:INIT_PORT\r\n");
		
#if 0	/* due 802.1y Z.4 */
			port->role = DisabledPort;
#else
			port->role = port->selectedRole = DisabledPort;
			port->reselect = True;
#endif
			port->synced = False;	/* in INIT */
			port->sync = True;	/* in INIT */
			port->reRoot = True;	/* in INIT_PORT */
			port->rrWhile = stpm->rootTimes.ForwardDelay;
			port->fdWhile = stpm->rootTimes.ForwardDelay;
			port->rbWhile = 0;
#ifdef STP_DBG
			if (this->debug)
				STP_port_trace_flags ("after init", port);
#endif
			break;
		case BLOCK_PORT:
	
			mn_fd_printf(cl_serv_console_fd,"roletrn:BLOCK_PORT\r\n");


			port->role = port->selectedRole;
			port->learn = port->forward = False;
			break;
		case BLOCKED_PORT:

			mn_fd_printf(cl_serv_console_fd,"roletrn:BLOCKED_PORT\r\n");
	

			port->fdWhile = stpm->rootTimes.ForwardDelay;
			port->synced = True;	/* In BLOCKED_PORT */
			port->rrWhile = 0;
			port->sync = port->reRoot = False;	/* BLOCKED_PORT */
			break;
		case BACKUP_PORT:

			mn_fd_printf(cl_serv_console_fd,"roletrn:BACKUP_PORT\r\n");
	

			port->rbWhile = 2 * stpm->rootTimes.HelloTime;
			break;

			/* 17.23.2 */
		case ROOT_PROPOSED:
		
			mn_fd_printf(cl_serv_console_fd,"roletrn:ROOT_PROPOSED\r\n");
	

			setSyncBridge (this);
			port->proposed = False;
#ifdef STP_DBG
			if (this->debug)
				STP_port_trace_flags ("ROOT_PROPOSED\r\n", port);
#endif
			break;
		case ROOT_AGREED:
		
			mn_fd_printf(cl_serv_console_fd,"roletrn:ROOT_AGREED\r\n");
	
			port->proposed = port->sync = False;	/* in ROOT_AGREED */
			port->synced = True;	/* In ROOT_AGREED */
			port->newInfo = True;
#ifdef STP_DBG
			if (this->debug)
				STP_port_trace_flags ("ROOT_AGREED\r\n", port);
#endif
			break;
		case REROOT:
		
			mn_fd_printf(cl_serv_console_fd,"roletrn:REROOT\r\n");
	

			setReRootBridge (this);
#ifdef STP_DBG
			if (this->debug)
				STP_port_trace_flags ("REROOT\r\n", port);
#endif
			break;
		case ROOT_PORT:
		
			mn_fd_printf(cl_serv_console_fd,"roletrn:ROOT_PORT\r\n");
		

			port->role = RootPort;
			port->rrWhile = stpm->rootTimes.ForwardDelay;
#ifdef STP_DBG
			if (this->debug)
				STP_port_trace_flags ("ROOT_PORT\r\n", port);
#endif
			break;
		case REROOTED:
		
			mn_fd_printf(cl_serv_console_fd,"roletrn:REROOTED\r\n");
		

			port->reRoot = False;	/* In REROOTED */
#ifdef STP_DBG
			if (this->debug)
				STP_port_trace_flags ("REROOTED\r\n", port);
#endif
			break;
		case ROOT_LEARN:
		
			mn_fd_printf(cl_serv_console_fd,"roletrn:ROOT_LEARN\r\n");
		

			port->fdWhile = stpm->rootTimes.ForwardDelay;
			port->learn = True;
#ifdef STP_DBG
			if (this->debug)
				STP_port_trace_flags ("ROOT_LEARN\r\n", port);
#endif
			break;
		case ROOT_FORWARD:
		
			mn_fd_printf(cl_serv_console_fd,"roletrn:ROOT_FORWARD\r\n");
		

			port->fdWhile = 0;
			port->forward = True;
#ifdef STP_DBG
			if (this->debug)
				STP_port_trace_flags ("ROOT_FORWARD\r\n", port);
#endif
			break;

			/* 17.23.3 */
		case DESIGNATED_PROPOSE:
		
			mn_fd_printf(cl_serv_console_fd,"roletrn:DESIGNATED_PROPOSE\r\n");
		

			port->proposing = True;	/* in DESIGNATED_PROPOSE */
			port->newInfo = True;
#ifdef STP_DBG
			if (this->debug)
				STP_port_trace_flags ("DESIGNATED_PROPOSE\r\n", port);
#endif
			break;
		case DESIGNATED_SYNCED:
		
			mn_fd_printf(cl_serv_console_fd,"roletrn:DESIGNATED_SYNCED\r\n");
	

			port->rrWhile = 0;
			port->synced = True;	/* DESIGNATED_SYNCED */
			port->sync = False;	/* DESIGNATED_SYNCED */
#ifdef STP_DBG
			if (this->debug)
				STP_port_trace_flags ("DESIGNATED_SYNCED\r\n", port);
#endif
			break;
		case DESIGNATED_RETIRED:
		
			mn_fd_printf(cl_serv_console_fd,"roletrn:DESIGNATED_RETIRED\r\n");
	

			port->reRoot = False;	/* DESIGNATED_RETIRED */
#ifdef STP_DBG
			if (this->debug)
				STP_port_trace_flags ("DESIGNATED_RETIRED\r\n", port);
#endif
			break;
		case DESIGNATED_PORT: