/********************************************************                                                                                                            
* 文件名  ： RsspLnkNodeMgrWl.c     
* 版权说明： 北京瑞安时代科技有限责任公司 
* 版本号  ： 1.0
* 创建时间： 2009.12.07
* 作者    ： 车载及协议部
* 功能描述： 通信节点数组相关操作，包含初始化，查询，覆盖等操作。
* 使用注意：调用本文件中的函数必须首先调用初始化的函数。 
*   
* 修改记录：   
*   时间		修改人	理由
* ------------  ------  ---------------
*	2009.12.07	楼宇伟	初版作成
*   2013.02.19  王佩佩  删除InitRsspLnkInfo，增加InitRsspLnkInfoWl
*   2013.02.19  王佩佩  删除SetNodeParam，增加SetNodeParamWl
*   2013.02.19  王佩佩  删除CheckRecvDsuLnkInfo，增加CheckRecvDsuLnkInfoWl
*   2013.02.19  王佩佩  删除CheckOutputDsuLnkInfo，增加CheckOutputDsuLnkInfoWl
*   2013.02.19  王佩佩  删除CheckInputAddr，增加CheckInputAddrWl
*   2013.02.19  王佩佩  删除InitRsspLnkInfo，增加InitRsspLnkInfoWl
*   2013.02.19  王佩佩  删除InitRsspLnkInfo，增加InitRsspLnkInfoWl
*   2014.01.15  王佩佩  修改SearchNodeByAddr_WL的处理过程
********************************************************/ 
#include <stdlib.h>
#include "RsspIFWL.h"
#include "RsspCommonWl.h"
#include "dsuRsspFunc.h"
#include "RsspLnkNodeMgrWl.h"
#include "Convert.h"
#include "RsspConfigWl.h"
#include "CommonRecord.h"

#ifdef __cplusplus
extern "C" {
#endif

/*--------------------------------------------------------------------
 * 链路管理模块内部函数申明 Start
 *--------------------------------------------------------------------*/
static UINT8 InitRsspLnkInfoWl(const DSU_RSSP_LINK_RINFO_STRU_WL* pRecvDsuLnkInf, const DSU_RSSP_LINK_SINFO_STRU_WL* pOutputDsuLnkInf, RsspLinkInfoStru_WL* pRsspLnkInfo, DSU_RSSP_INFO_STRU_WL *pDsuRsspi);
static UINT8 SetNodeParamWl(const DSU_RSSP_LINK_RINFO_STRU_WL* pRecvDsuLnkInf, const DSU_RSSP_LINK_SINFO_STRU_WL* pOutputDsuLnkInf, NodeParamInfoStru_WL *pNodeParam);
static void LnkNodeInfo2VarArray_WL(const Lnk_Info_Node_Stru_WL* pNode, const UINT8 lnkNodeIdx, UINT8* VarArray);
static void VarArray2LnkNodeInfo_WL(const UINT8* VarArray, Lnk_Info_Node_Stru_WL* pNode);
static UINT8 CheckRecvDsuLnkInfoWl(UINT16 LocalDevName, const DataNode_WL *pNode, const DSU_RSSP_LINK_RINFO_STRU_WL *pRecvLnkInfo, DSU_RSSP_INFO_STRU_WL *pDsuRsspi);
static UINT8 CheckOutputDsuLnkInfoWl(UINT16 LocalDevName, const DataNode_WL *pNode, const DSU_RSSP_LINK_SINFO_STRU_WL *pOutputLnkInfo, DSU_RSSP_INFO_STRU_WL *pDsuRsspi);
static UINT8 CheckInputAddrWl(UINT32 LocalDevName,UINT16 SrcAddr,const DSU_RSSP_LINK_RINFO_STRU_WL *pRecvLnkInfo);
/*--------------------------------------------------------------------
 * 链路管理模块内部函数申明 End
 *--------------------------------------------------------------------*/

/*--------------------------------------------------------------------
 * RSSP层对外提供的接口函数 Start
 *--------------------------------------------------------------------*/

 /*
 *函数名:	RsspLnkStatus_WL
 *功能描述:	得到某个安全接受节点的在本周期得通信状态：
 * 				存在某个安全接受节点，则返回该安全节点的通信状态
 * 				不存在某个安全接收节点，则返回错误
 *输入参数:	UINT8 dstType		目的类型
 *			UINT8 dstId			目的ID
 *			UINT16 dstLogicId	目的逻辑ID	
 *			RSSP_INFO_STRU *pRsspi	RSSPI信息
 *输入出参:	无
 *输出参数:	链路状态 0x17:接收数据,0x2b:通信不正常
 *返回值:	无
 */
UINT8 RsspLnkStatus_WL(UINT8 dstType, UINT8 dstId, UINT16 dstLogicId, RSSP_INFO_STRU *pRsspi)
{
	UINT8 rtn = 0;	/*返回值*/
	UINT32 oppId = 0;	/*对方唯一ID*/
	Lnk_Info_Node_Stru_WL *pNode = NULL;	/*链路节点*/
	UINT16 dstName = 0U;
	if (NULL != pRsspi)
	{

#ifdef RSSP_NO_HLHT
		TypeId2DevName_WL(dstType, dstId, &dstName);	/*获取目的RSSPI唯一ID*/
		oppId = dstName;

#else
		oppId = DquToHlhtId(dstType, dstId, dstLogicId, pRsspi->pDsuRsspInfoStruWL);	/*获取目的RSSPI唯一ID*/
#endif
		
		pNode = SearchNodeByAddr_WL(oppId, pRsspi);
	}
	
	if (NULL != pNode)
	{
		if (RecvData_WL == pNode->RsspLinInfo.RecvLinkStatus)
		{
			rtn = 0x17;	/*接收数据状态*/
		}
		else
		{
			rtn = 0x2b;	/*通信不正常状态*/
		}
	}

	return rtn;
}

/***********************************************************************
 * 方法名   : RsspLnkDelete_WL
 * 功能描述 : 通过该函数，应用可以删除某个发送节点。当应用不再需要对某个对象发送数据时，利用该函数删除相应的发送节点。
 * 输入参数 : 
 *	参数名				类型							输入输出		描述
 *  --------------------------------------------------------------
 *  devName         UINT16*         OUT             设备名称
 * 返回值   : UINT8  1：正常返回  0：错误返回
 ***********************************************************************/
UINT8 RsspLnkDelete_WL(UINT32 destDevName,RSSP_INFO_STRU *pRsspStruct)
{
	UINT8 ret = 0;

	Lnk_Info_Node_Stru_WL* pNode = NULL;
	pNode = SearchNodeByAddr_WL(destDevName,pRsspStruct);
	if(pNode == NULL)
	{
		ret = 0;
	}	
	else
	{
		/*清空链路信息*/
		RsspMemSet_WL((UINT8*)pNode, sizeof(Lnk_Info_Node_Stru_WL), 0);
		/* 通信节点的状态设为 可覆盖状态 */
		pNode->NodeStatus = Replace_WL;
		ret = 1;
	}
	
	return ret;
}

 /**
  * @brief RsspRefresh_WL 刷新链路
  * @param VarLen 链路数据长度 取值范围:0x0000-0xFFFF
  * @param VarArray 链路数据数组 取值范围:字节数组
  * @param pRsspStruct RSSPI实例 取值范围:参考结构体:RSSP_INFO_STRU
  * @return 0:失败 1:成功
  */
UINT8 RsspRefresh_WL(UINT16 VarLen, const UINT8* VarArray, RSSP_INFO_STRU* pRsspStruct)
{
	UINT8 ret = 1u; /*-< 设置函数返回值为成功*/

	UINT8 NodeLen = 0u; /*设置节点长度为0*/
	UINT8 NodeNum = 0u; /*设置节点数量为0*/
	UINT8 index = 0u; /*设置数量下标为0*/
	UINT16 offset = 0u; /*设置数据下标为0*/
	DSU_RSSP_LINK_RINFO_STRU_WL recvLnkInfo; /*本方作为接收方时候的节点基本信息*/
	DSU_RSSP_LINK_SINFO_STRU_WL outputLnkInfo; /*本方作为发送方时候的节点基本信息*/
	UINT8 lnkNodeIdx = 0u; /*设置链路节点下标为0*/

	NodeLen = RSSP_VAR_NODE_LEN_WL; /*-< 设置函数返回值为成功*/
	if ((0u == (VarLen % NodeLen)) && (UINT8_MAX >= (VarLen / NodeLen))) /*-< 链路数据长度是否单节点链路长度整数倍 且小于UINT8_MAX值*/
	{
		NodeNum = (UINT8)(VarLen / NodeLen); /*-< 设置要刷链路节点数*/
	}
	else
	{
		return 0u; /*-< 返回函数失败*/
	}

	if ((NULL != VarArray) && (NULL != pRsspStruct) && (NULL != pRsspStruct->LnkNodeArr)) /*-< 入参是否非空*/
	{
		RsspMemSet_WL((UINT8*)pRsspStruct->LnkNodeArr, sizeof(Lnk_Info_Node_Stru_WL) * pRsspStruct->LnkNodeNum, 0); /*-< 清零链路节点数组*/

		for (index = 0u; index < pRsspStruct->LnkNodeNum; index++) /*-< 当前链路数下标是否小于链路总数*/
		{
			pRsspStruct->LnkNodeArr[index].NodeStatus = Replace_WL; /*-< 设置当前链路节点状态为不可用*/
		}
	}
	else
	{
		return 0; /*-< 返回函数失败*/
	}

	if (NodeNum <= pRsspStruct->LnkNodeNum) /*-< 要刷链路节点数是否小于最大链路数*/
	{
		for (index = 0; index < NodeNum; index++) /*-< 当前链路数下标是否小于链路总数*/
		{
			lnkNodeIdx = VarArray[offset]; /*-< 设置链路节点下标为要刷链路节点下标*/
			if (lnkNodeIdx < pRsspStruct->LnkNodeNum) /*-< 要刷当前链路节点下标是否小于最大链路数*/
			{
				VarArray2LnkNodeInfo_WL(&VarArray[offset], &pRsspStruct->LnkNodeArr[lnkNodeIdx]); /*-< 调用设置链路节点数据函数*/

				if (0u != pRsspStruct->LnkNodeArr[lnkNodeIdx].DestDevName) /*-< 当前链路节点对方唯一ID是否非0*/
				{
					/* 本方做为发送方基本信息取得 */
					ret = dsuRsspSGetLnkInfoWl(pRsspStruct->LnkNodeArr[lnkNodeIdx].RsspLinInfo.RsspSrcAddr,
						pRsspStruct->LnkNodeArr[lnkNodeIdx].RsspLinInfo.DestBsdAdd,
						&outputLnkInfo, pRsspStruct->pDsuRsspInfoStruWL); /*-< 调用查询发送方链路信息函数,结果赋值给函数返回值*/
					if (ret == 0u) /*-< 函数返回值是否失败*/
					{
						return ret; /*-< 返回函数返回值*/
					}
					else
					{
						/*-< 什么不做*/
					}

					/* 本方做为接收方基本信息取得 */
					ret = dsuRsspRGetLnkInfoWl(pRsspStruct->LnkNodeArr[lnkNodeIdx].RsspLinInfo.RsspDestAddr,
						pRsspStruct->LnkNodeArr[lnkNodeIdx].RsspLinInfo.RsspSrcAddr,
						&recvLnkInfo, pRsspStruct->pDsuRsspInfoStruWL); /*-< 调用查询接收方链路信息函数,结果赋值给函数返回值*/
					if (ret == 0) /*-< 函数返回值是否失败*/
					{
						return ret; /*-< 返回函数返回值*/
					}
					else
					{
						/*-< 什么不做*/
					}
					/* 设备基本信息设定 */
					ret = SetNodeParamWl(&recvLnkInfo, &outputLnkInfo,
						&pRsspStruct->LnkNodeArr[lnkNodeIdx].RsspLinInfo.LocalNode); /*-< 调用设置链路参数函数,结果赋值给函数返回值*/
				}
				else
				{
					/*-< 什么不做*/
				}
			}
			else
			{
				PrintRecArray2ByteB(pRsspStruct->RecordArray, pRsspStruct->RecordArraySize, 0x8801u); /*-< 记录刷新链路下标错误日志*/
				PrintRecArrayByte(pRsspStruct->RecordArray, pRsspStruct->RecordArraySize, lnkNodeIdx); /*-< 记录刷新链路标志日志*/
				PrintRecArrayByte(pRsspStruct->RecordArray, pRsspStruct->RecordArraySize, pRsspStruct->LnkNodeNum); /*-< 记录刷新链路标志日志*/

				return 0u; /*-< 返回函数失败*/
			}

			offset += NodeLen; /*-< 数据下标增链路长度*/
		}
	}
	else
	{
		return 0; /*-< 返回函数失败*/
	}

	PrintRecArray2ByteB(pRsspStruct->RecordArray, pRsspStruct->RecordArraySize, 0x8800u); /*-< 记录刷新链路标志日志*/
	ret = 1; /*-< 设置函数返回值为成功*/
	return ret; /*-< 返回函数返回值*/
}

/***********************************************************************
 * 方法名   : GetLnkNodeArr_WL
 * 功能描述 : 取得全局的通信节点数组指针以及通信节点个数。
 * 输入参数 : 
 *	参数名				类型					输入输出		描述
 *  -----------------------------------------------------------------------------
 *	pLnkInfoNodeArr		Lnk_Info_Node_Stru_WL**	OUT				通信数组指针的指针
 *  OutLen				UINT8*					OUT				长度
 * 
 * 返回值   : 无
 ***********************************************************************/
 void GetLnkNodeArr_WL(Lnk_Info_Node_Stru_WL** pLnkInfoNodeArr,UINT8 *OutLen,RSSP_INFO_STRU *pRsspStruct)
{
	*pLnkInfoNodeArr = pRsspStruct->LnkNodeArr;	
	*OutLen = pRsspStruct->LnkNodeNum;
}

/**
 * @brief InitLnkNodeArr_WL 初始化链路节点数组
 * @param num 链路总数 取值范围:0x00-0xFF
 * @param pRsspStruct RSSPI实例 取值范围:参考结构体:RSSP_INFO_STRU
 * @return 0:失败 1:成功
 */
 UINT8 InitLnkNodeArr_WL(UINT8 num, RSSP_INFO_STRU* pRsspStruct)
 {
	 UINT8 ret = 1u; /*-< 设置函数返回值为成功*/
	 UINT8 index = 0u; /*链路数下标*/
	 UINT32 lnkNodeArrSize = 0u; /*链路数组长度*/
	 pRsspStruct->LnkNodeNum = num; /*-< 设置链路数给RSSPI实例链路数*/
	 lnkNodeArrSize = sizeof(Lnk_Info_Node_Stru_WL) * pRsspStruct->LnkNodeNum; /*-< 计算链路数组长度*/
	 pRsspStruct->LnkNodeArr = (Lnk_Info_Node_Stru_WL*)malloc(lnkNodeArrSize); /*-< 分配链路数组空间*/
	 if (NULL == pRsspStruct->LnkNodeArr) /*-< 是否分配失败*/
	 {
		 ret = 0u; /*-< 设置函数返回值为成功*/
	 }
	 else
	 {
		 RsspMemSet_WL((UINT8*)pRsspStruct->LnkNodeArr, lnkNodeArrSize, 0); /*-< 清零链路数据数组*/
	 }
	 for (index = 0u; index < pRsspStruct->LnkNodeNum; index++) /*-< 当前链路数下标是否小于链路总数*/
	 {
		 pRsspStruct->LnkNodeArr[index].NodeStatus = Replace_WL; /*-< 设置当前链路节点为不可用*/

		 pRsspStruct->LnkNodeArr[index].RecvKeepHaltCycleNum = 0u; /*-< 清零接收保持Halt_WL状态周期数*/
		 pRsspStruct->LnkNodeArr[index].RecvKeepSendSseCycleNum = 0u; /*-< 清零接收保持SendSSE_WL状态周期数*/
	 }

	 return ret; /*-< 返回函数返回值*/
 }

/***********************************************************************
 * 方法名   : SearchLnkBsdNode_WL
 * 功能描述 : 根据Bsd地址和源地址查询相应的通信节点，如果通信节点存在就返回相对应的
 *			  地址。否则返回NULL。
 * 输入参数 : 
 *	参数名	  类型			输入输出		描述
 *  --------------------------------------------------------------
 *	RsspSrcAddr   UINT16		IN				Rssp源地址
 *  DestBsdAdd	  UINT16		IN				Bsd地址
 * 
 * 全局变量 : LnkNodeArr		全局变量
 * 返回值   : Lnk_Info_Node_Stru_WL*  NULL:指定节点不存在  !=NULL 指定节点地址
 ***********************************************************************/
Lnk_Info_Node_Stru_WL* SearchLnkBsdNode_WL(UINT16 RsspSrcAddr,UINT16 DestBsdAdd,RSSP_INFO_STRU *pRsspStruct)
{
	UINT8 index = 0;
	Lnk_Info_Node_Stru_WL* retNodePtr = NULL;

	for(index = 0; index < pRsspStruct->LnkNodeNum; index++)
	{	
		/* wangpeipei 20120319 Mod */
		/* 根据BSD地址和源地址查询 */
		if((DisbaledReplace_WL == pRsspStruct->LnkNodeArr[index].NodeStatus)
			&& (pRsspStruct->LnkNodeArr[index].RsspLinInfo.RsspSrcAddr == DestBsdAdd)
			&& (pRsspStruct->LnkNodeArr[index].RsspLinInfo.RsspDestAddr== RsspSrcAddr))
		{
			retNodePtr = & pRsspStruct->LnkNodeArr[index];
			break;
		}
		else
		{
			/* nothing */
		}
	}
	return retNodePtr;
}

/***********************************************************************
 * 方法名   : SearchLnkSse_SsrNode_WL
 * 功能描述 : 根据PSSP目的地址和源地址查询相应的通信节点，如果通信节点存在就返回相对应的
 *			  地址。否则返回NULL。
 * 输入参数 : 
 *	参数名	  类型			输入输出		描述
 *  --------------------------------------------------------------
 *	RsspSrcAddr   UINT16		IN				Rssp源地址
 *  RsspDestAddr	  UINT16		IN		    Pssp目的地址
 * 
 * 全局变量 : LnkNodeArr		全局变量
 * 返回值   : Lnk_Info_Node_Stru_WL*  NULL:指定节点不存在  !=NULL 指定节点地址
 ***********************************************************************/
Lnk_Info_Node_Stru_WL* SearchLnkSse_SsrNode_WL(UINT16 RsspSrcAddr,UINT16 RsspDestAddr,RSSP_INFO_STRU *pRsspStruct)
{
	UINT8 index = 0;
	Lnk_Info_Node_Stru_WL* retNodePtr = NULL;

	for(index = 0; index < pRsspStruct->LnkNodeNum; index++)
	{
	
		/* 根据指定动态Id 以及 标识取得对应节点的信息 */
		if((DisbaledReplace_WL == pRsspStruct->LnkNodeArr[index].NodeStatus)
			&& (pRsspStruct->LnkNodeArr[index].RsspLinInfo.RsspDestAddr == RsspDestAddr)
			&& (pRsspStruct->LnkNodeArr[index].RsspLinInfo.RsspSrcAddr == RsspSrcAddr))
		{
			retNodePtr = & pRsspStruct->LnkNodeArr[index];
			break;
		}
		else
		{
			/* nothing */
		}

	}
	return retNodePtr;
}
/* wangpeipei 20111201 ADD */

/***********************************************************************
 * 方法名   : GetReplaceNode_WL
 * 功能描述 : 返回通信数组可覆盖的节点。
 * 输入参数 : 
 *	参数名		类型	输入输出	描述
 *  --------------------------------------------------------------
 * 
 * 全局变量 : LnkNodeArr*		全局变量通信节点数组
 * 返回值   : Lnk_Info_Node_Stru_WL*  NULL：异常 非NULL：通信节点数组
 ***********************************************************************/

Lnk_Info_Node_Stru_WL* GetReplaceNode_WL(RSSP_INFO_STRU *pRsspStruct)
/* wangpeipei 20111202 Add S */
{
	UINT8 index = 0;
	Lnk_Info_Node_Stru_WL* retNodePtr = NULL;

    for(index = 0; index < pRsspStruct->LnkNodeNum; index++)
	{
		/* 如果该节点可覆盖 则 返回该节点的指针 */
		/*if((srcAddr == LnkNodeArr[index].RsspSrcAddr) && (desAddr == LnkNodeArr[index].RsspDestAddr)
			&& (LnkNodeArr[index].NodeStatus == Replace))*/
		if(pRsspStruct->LnkNodeArr[index].NodeStatus == Replace_WL)
		{
			retNodePtr = &pRsspStruct->LnkNodeArr[index];
			break;
		}
		else
		{
			/* 什么都不做 */
		}
	}
    /* wangpeipei 20111202 Mod E */
	return retNodePtr;
}


/***********************************************************************
 * 方法名   : DestoryLnkNodeArr_WL
 * 功能描述 : 释放通信节点数组的空间
 * 输入参数 : 
 *	参数名				类型				输入输出		描述
 *  -------------------------------------------------------------
 *	无
 *
 * 返回值   : 无。
 ***********************************************************************/
void DestoryLnkNodeArr_WL(RSSP_INFO_STRU *pRsspStruct)
{
	/* 通信节点数组的空间不为空，则释放内存空间 */
	if(NULL != pRsspStruct->LnkNodeArr)
	{
		free(pRsspStruct->LnkNodeArr);
		pRsspStruct->LnkNodeArr = NULL;
		pRsspStruct->LnkNodeNum = 0;
	}
	else
	{
		/* 什么不做 */
	}
}

/***********************************************************************
 * 方法名   : recvReplaceLnkNode_WL
 * 功能描述 : 根据报文信息，将通信节点信息初始化。
 * 输入参数 : 
 *	参数名			类型				输入输出		描述
 *  -------------------------------------------------------------
 *  LocalDevName	UINT16				IN				本方标识符
 *	pDataNode		const DataNode_WL*		IN				报文节点
 *  pLnkNodeInfo	通信节点			INOUT			通信节点
 *
 * 返回值   : UINT8  1：正常返回  0：错误返回
 * 使用限制 ：本函数为输入模块在收到BSD报文时对应通信节点不存在时调用
 *
 ***********************************************************************/
UINT8 recvReplaceLnkNode_WL(UINT16 LocalDevName,const DataNode_WL* pDataNode,Lnk_Info_Node_Stru_WL *pLnkNodeInfo, DSU_RSSP_INFO_STRU_WL *pDsuRsrInfoStru_WL)
{
	UINT8 ret = 0,checkRet = 0;
	UINT16 BsdAddr = 0;
	UINT16 DestSrcAddr = 0;
	DSU_RSSP_LINK_RINFO_STRU_WL recvLnkInfo;		/* 本方作为接收方时候的节点基本信息 */
	DSU_RSSP_LINK_SINFO_STRU_WL outputLnkInfo;		/* 本方作为发送方时候的节点基本信息 */
	
	/* BSD报文里面的目标地址 即为 BSD地址 */
	BsdAddr = (INT16)ShortFromCharLE(&pDataNode->Data[RSSP_DEST_ADD_POS_WL]);
	/* BSD报文的报文里面源地址 即对方SSE地址 */
	DestSrcAddr = ShortFromCharLE(&pDataNode->Data[RSSP_SRC_ADD_POS_WL]);

	/* 根据接收报文的源地址以及目标地址(BSD地址)取得本方作为接受节点的信息 */
	ret = dsuRsspRGetLnkInfoWl(DestSrcAddr, 
			BsdAddr, &recvLnkInfo, pDsuRsrInfoStru_WL);
	/* 取得成功 而且 基本信息和临时报文节点信息一致 */
	checkRet = CheckRecvDsuLnkInfoWl(LocalDevName, pDataNode, &recvLnkInfo, pDsuRsrInfoStru_WL);
	if((0 == ret) || (0 == checkRet))
	{
		ret = 0;
		return ret;
	}
	/* 根据取得的Sse地址以及目标地址(BSD地址)取得本方作为发送节点的信息 */

	ret = dsuRsspSGetLnkInfoWl(recvLnkInfo.SseAddr, (INT16)DestSrcAddr, &outputLnkInfo, pDsuRsrInfoStru_WL);
	/* 取得成功 而且 基本信息和临时报文节点信息一致 */
	checkRet = CheckOutputDsuLnkInfoWl(LocalDevName, pDataNode, &outputLnkInfo, pDsuRsrInfoStru_WL);
	if((0 == ret) || (0 == checkRet))
	{
		ret = 0;
		return ret;
	}

	/* 对方标识符设定 */
	pLnkNodeInfo->DestDevName = pDataNode->DevName;

	/* RSSP链路基本信息结构体初始化 */
	InitRsspLnkInfoWl(&recvLnkInfo, &outputLnkInfo, &pLnkNodeInfo->RsspLinInfo, pDsuRsrInfoStru_WL);

	/* 通信节点的接受状态设置为发送SSE。 */
	pLnkNodeInfo->RsspLinInfo.RecvLinkStatus = SendSSE_WL;

	/* 通信节点状态设定为不可覆盖   */
	pLnkNodeInfo->NodeStatus = DisbaledReplace_WL;

	ret = 1;
	return ret;

}
/***********************************************************************
 * 方法名   : outputReplaceLnkNode_WL
 * 功能描述 : 根据源地址，目标地址，BSD地址取得对应节点信息，
 *				将通信节点信息初始化。
 * 输入参数 : 
 *	参数名			类型					输入输出		描述
 *  -------------------------------------------------------------
 *  SrcAddr			UINT16					IN				源地址
 *  BsdAddr			UINT16					IN				BSD地址
 *  DestAddr		UINT16					IN				SSE地址
 *  LocalDevName			UINT32			IN				本方标识符
 *  pPLnkNodeInfo	Lnk_Info_Node_Stru_WL**	OUT			通信节点
 *
 * 返回值   : UINT8  1：正常返回  0：错误返回
 * 使用限制 ：本函数为输出模块，指定地址的通信节点不存在时调用
 *
 ***********************************************************************/
UINT8 outputReplaceLnkNode_WL(UINT16 SrcAddr,UINT16 BsdAddr,UINT16 DestAddr,
						   UINT32 LocalDevName,Lnk_Info_Node_Stru_WL **pPLnkNodeInfo,
						   RSSP_INFO_STRU *pRsspStruct)
{
	UINT8 ret = 0,chcRet = 0;
	DSU_RSSP_LINK_RINFO_STRU_WL recvLnkInfo;		/* 本方作为接收方时候的节点基本信息 */
	DSU_RSSP_LINK_SINFO_STRU_WL outputLnkInfo;		/* 本方作为发送方时候的节点基本信息 */
	Lnk_Info_Node_Stru_WL *pLnkNodeInfo = NULL;

	/* 根据参数目标地址以及BSD地址取得本方作为接受节点的信息 */
	ret = dsuRsspRGetLnkInfoWl(DestAddr, SrcAddr, &recvLnkInfo, pRsspStruct->pDsuRsspInfoStruWL);
	/* 
	 * 取得成功 而且 接受信息与本方信息一致
	 */
	chcRet = CheckInputAddrWl(LocalDevName,SrcAddr,&recvLnkInfo);
	if((1 == ret) && ( 1 == chcRet))
	{
		/* 根据取得的Sse地址以及目标地址(BSD地址)取得本方作为发送节点的信息 */
		ret = dsuRsspSGetLnkInfoWl(recvLnkInfo.SseAddr, BsdAddr, &outputLnkInfo, pRsspStruct->pDsuRsspInfoStruWL);
		if(0 == ret)
		{
			/* 取得失败，错误返回 */
			return ret;
		}

		pLnkNodeInfo = GetReplaceNode_WL(pRsspStruct);
		if(NULL == pLnkNodeInfo)
		{
			/* 可覆盖节点取得失败 则错误返回 */
			ret = 0;
			return ret;
		}
		else
		{
			/* 取得的覆盖节点指针 保存返回pPLnKNodeInfo里面 */
			*pPLnkNodeInfo = pLnkNodeInfo;		
		}
		/* 对方标识符设定 */
		pLnkNodeInfo->DestDevName = outputLnkInfo.DestName;

		/* RSSP链路基本信息结构体初始化 */
		InitRsspLnkInfoWl(&recvLnkInfo, &outputLnkInfo, &pLnkNodeInfo->RsspLinInfo, pRsspStruct->pDsuRsspInfoStruWL);

		/* 通信节点状态设定为不可覆盖   */
		pLnkNodeInfo->NodeStatus = DisbaledReplace_WL;
	}
	else
	{
		/* 接受信息取得失败 或者 通信关系式 仿真CI和CC 或者 地址关系不对 */
		ret = 0;
		return ret;
	}

	ret = 1;
	return ret;
}

/***********************************************************************
 * 方法名   :   SearchNodeByAddr_WL
 * 功能描述 : 根据指定的对方设备标识查询对应通信节点是否存在。
 *				存在则返回对应通信节点指针，否则返回NULL。
 * 输入参数 : 
 *	参数名		类型	输入输出	描述
 *  --------------------------------------------------------------------------
 *	destName		UINT32	 IN		对方设备标识
 *
 * 返回值   :	Lnk_Info_Node_Stru_WL* 通信节点指针， NULL:不存在
 ***********************************************************************/
Lnk_Info_Node_Stru_WL* SearchNodeByAddr_WL(UINT32 destName,RSSP_INFO_STRU *pRsspStruct)
{
	UINT8 index = 0;
	Lnk_Info_Node_Stru_WL* retLnkNodePtr = NULL;	/* 返回指针 */
	for( index = 0; index < pRsspStruct->LnkNodeNum; index++)
	{
		/*
		 * 指定的地址查找相对应的通信节点
		 */
    if((DisbaledReplace_WL == pRsspStruct->LnkNodeArr[index].NodeStatus)
		&& (destName == pRsspStruct->LnkNodeArr[index].DestDevName))
		{
			retLnkNodePtr = & pRsspStruct->LnkNodeArr[index];
			break;
		}
		else
		{
			/* 继续判断下一结点 */
		}
	}
	
	return retLnkNodePtr;
}

/*--------------------------------------------------------------------
 * RSSP层内部接口函数定义 End
 *--------------------------------------------------------------------*/

/*--------------------------------------------------------------------
 * 链路管理模块内部函数申明 Start
 *--------------------------------------------------------------------*/
/***********************************************************************
 * 方法名   :   InitRsspLnkInfo
 * 功能描述 : 根据发送信息以及接受信息，对链路基本信息进行初始化。
 * 输入参数 : 
 *	参数名				类型							输入输出	描述
 *  --------------------------------------------------------------------------
 *  pRecvDsuLnkInf		const DSU_RSSP_LINK_RINFO_STRU_WL*	 IN			接受信息
 *  pOutputDsuLnkInf	const DSU_RSSP_LINK_SINFO_STRU_WL*	 IN			发送信息
 *	pRsspLnkInfo		RsspLinkInfoStru_WL*				 INOUT		链路基本信息结构体
 *
 * 返回值   : UINT8  1：正常返回  0：错误返回
 ***********************************************************************/
/* MOD 20130802 删除 BsdAddr */
static UINT8 InitRsspLnkInfoWl(const DSU_RSSP_LINK_RINFO_STRU_WL* pRecvDsuLnkInf, 
							const DSU_RSSP_LINK_SINFO_STRU_WL* pOutputDsuLnkInf, 
							RsspLinkInfoStru_WL* pRsspLnkInfo,
							DSU_RSSP_INFO_STRU_WL *pDsuRsspi)
{
	UINT8 ret = 0;
    
	/* ADD  20130802 */
	if(pOutputDsuLnkInf == NULL)
	{
		ret = 0;
	}
	else
	{
		/* 内容清空 */
		RsspMemSet_WL((UINT8 *)pRsspLnkInfo,sizeof(RsspLinkInfoStru_WL),0);
#ifdef RSSP_NO_HLHT
		pRsspLnkInfo->DestLogId = pOutputDsuLnkInf->DestName & 0xff;
		pRsspLnkInfo->LocalLogId = pRecvDsuLnkInf->DestName & 0xff;
#else
		pRsspLnkInfo->DestLogId = DquToDevId(pOutputDsuLnkInf->DestName, pDsuRsspi);	/* 对方动态Id （对方设备Id）*/
		pRsspLnkInfo->LocalLogId = DquToDevId(pRecvDsuLnkInf->DestName, pDsuRsspi);	/* 接受基本信息的对方标识符为本方标识符，设备Id作为动态Id */
#endif	
		
		pRsspLnkInfo->RsspSrcAddr = pRecvDsuLnkInf->SseAddr;	/* RSSP源地址 （本方） = 接收方基本信息的SSe地址 */ 	
		pRsspLnkInfo->RsspDestAddr = pOutputDsuLnkInf->SseAddr;	/* RSSP目标地址(SSE地址) = 发送方基本信息的SSE地址 */

		/* BSD地址设定 */
		pRsspLnkInfo->DestBsdAdd = pOutputDsuLnkInf->SseAddr;

		/* 设定通信节点的基本信息 */
		SetNodeParamWl(pRecvDsuLnkInf, pOutputDsuLnkInf, &pRsspLnkInfo->LocalNode);
			
		pRsspLnkInfo->RecvLinkStatus = Halt_WL;	/* 链路接受状态设定为中断状态 */
		pRsspLnkInfo->SendLinkStatus = Halt_WL;	/* 链路发送状态设定为中断状态 */	
		pRsspLnkInfo->NoRecvDataCycleNum = 0;	/* 无数据周期数初始化为0 */	
		pRsspLnkInfo->NoAppDataCycleNum = 0;	/* 无发送应用数据周期数初始化为0 */

		/*pRsspLnkInfo->TimeStmp.TC = 0;*/			/* 当前时间计数器设为0 */

		/* 当前周期对应时间戳用通信的发送方SID初始化 */
		pRsspLnkInfo->TimeStmp.NowTn[0] = pRsspLnkInfo->LocalNode.SIDr[0];
		pRsspLnkInfo->TimeStmp.NowTn[1] = pRsspLnkInfo->LocalNode.SIDr[1];
	    ret = 1;
	}
	return ret;		/* 固定返回1 */
}

 /**
  * @brief WriteToVarArray_WL 写入链路数据
  * @param VarArray 链路数据 取值范围：字节数组
  * @param pRsspStruct RSSPI实例 取值范围:参考结构体:RSSP_INFO_STRU
  * @return 0:失败 1:成功
  */
UINT8 WriteToVarArray_WL(UINT8* VarArray, RSSP_INFO_STRU* pRsspStruct)
{
	UINT8 ret = 0u, index = 0u; /*-< 设置函数返回值为失败*/
	UINT8* pTmp = NULL; /*链路数据*/
	UINT8 NodeLen = 0u; /*节点长度*/
	UINT8 count = 0u; /*可用节点数*/
	UINT16 offset = 0u; /*链路数据下标*/
	if ((NULL != VarArray) && (NULL != pRsspStruct)) /*-< 参数是否非空*/
	{
		NodeLen = (UINT8)RSSP_VAR_NODE_LEN_WL; /*-< 设置节点长度*/
		pTmp = &VarArray[2]; /*-< 设置链路数据*/
		for (index = 0u; index < pRsspStruct->LnkNodeNum; index++) /*-< 链路数下标是否小于链路总数*/
		{
			if (pRsspStruct->LnkNodeArr[index].NodeStatus == DisbaledReplace_WL) /*-< 当前链路可用性是否为可用*/
			{
				LnkNodeInfo2VarArray_WL(&pRsspStruct->LnkNodeArr[index], index, &pTmp[offset]); /*-< 调用链路节点写入链路数据函数*/

				offset += NodeLen; /*-< 链路数据下标自增链路节点长度*/
				count++; /*-< 可用节点数自增1*/
			}
		}

		ShortToChar((count * NodeLen), VarArray); /*-< 写入链路数据长度倒链路数据*/
		ret = 1u; /*-< 设置函数返回值为成功*/
	}

	return ret; /*-< 返回函数返回值*/
}

/**
 * @brief LnkNodeInfo2VarArray_WL 链路节点写入链路数据
 * @param pNode 链路节点 取值范围:参考结构体:Lnk_Info_Node_Stru_WL
 * @param lnkNodeIdx 链路节点下标 取值范围:0x00-0xFF
 * @param VarArray 链路数据 取值范围:字节数组
 */
static void LnkNodeInfo2VarArray_WL(const Lnk_Info_Node_Stru_WL* pNode, const UINT8 lnkNodeIdx, UINT8* VarArray)
{
	UINT16 index = 0; /*链路数据下标*/
	const RsspLinkInfoStru_WL* pRsspLnkInfo = &pNode->RsspLinInfo; /*当前链路信息*/
	const TimeStampStru_WL* pTmStmp = &pNode->RsspLinInfo.TimeStmp; /*当前链路时间戳*/

	VarArray[index++] = lnkNodeIdx; /*-< 设置链路节点下标给链路数据,下标自增1*/

	LongToChar(pNode->CycleNum, &VarArray[index]); /*-< 设置周期号给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	VarArray[index++] = pNode->ExeCycle; /*-< 设置是否为执行周期给链路数据,下标自增1*/

	VarArray[index++] = pNode->HasRsdBeforeSseOrSsr; /*-< 设置在生成SSE或者SSR之前是否有生成RSD给链路数据,下标自增1*/

	VarArray[index++] = pNode->RecvKeepHaltCycleNum; /*-< 设置接收保持Halt_WL状态周期数给链路数据,下标自增1*/

	VarArray[index++] = pNode->RecvKeepSendSseCycleNum; /*-< 设置接收保持SendSSE_WL状态周期数给链路数据,下标自增1*/

	LongToChar(pNode->DestDevName, &VarArray[index]); /*-< 设置对方唯一ID给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	ShortToChar(pNode->DestTypeId, &VarArray[index]); /*-< 设置对方类型ID给链路数据*/
	index += 2; /*-< 链路数据下标自增2*/

	ShortToChar(pNode->DestLogicId, &VarArray[index]); /*-< 设置对方逻辑ID给链路数据*/
	index += 2; /*-< 链路数据下标自增2*/

	VarArray[index++] = pNode->NodeStatus; /*-< 设置链路是否可用标识给链路数据,下标自增1*/

	VarArray[index++] = pRsspLnkInfo->LocalLogId; /*-< 设置本方动态ID给链路数据,下标自增1*/

	VarArray[index++] = pRsspLnkInfo->DestLogId; /*-< 设置对方动态ID给链路数据,下标自增1*/

	VarArray[index++] = pRsspLnkInfo->RecvLinkStatus; /*-< 设置链路接受状态给链路数据,下标自增1*/

	VarArray[index++] = pRsspLnkInfo->SendLinkStatus; /*-< 设置链路发送状态给链路数据,下标自增1*/

	VarArray[index++] = pRsspLnkInfo->NoRecvDataCycleNum; /*-< 设置无数据周期数给链路数据,下标自增1*/

	VarArray[index++] = pRsspLnkInfo->NoAppDataCycleNum; /*-< 设置无发送应用数据周期数给链路数据,下标自增1*/

	ShortToChar((UINT16)pRsspLnkInfo->DestBsdAdd, &VarArray[index]); /*-< 设置BSD地址给链路数据*/
	index += 2; /*-< 链路数据下标自增2*/

	ShortToChar(pRsspLnkInfo->RsspSrcAddr, &VarArray[index]); /*-< 设置RSSP源地址给链路数据*/
	index += 2; /*-< 链路数据下标自增2*/

	ShortToChar(pRsspLnkInfo->RsspDestAddr, &VarArray[index]); /*-< 设置RSSP目的地址给链路数据*/
	index += 2; /*-< 链路数据下标自增2*/

	LongToChar(pTmStmp->TC, &VarArray[index]); /*-< 设置当前时间计数器给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	LongToChar(pTmStmp->LastLocalRecTC, &VarArray[index]); /*-< 设置上次收到报文本地时钟给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	LongToChar(pTmStmp->NowTn[0], &VarArray[index]); /*-< 设置当前周期对应时间戳[0]给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	LongToChar(pTmStmp->NowTn[1], &VarArray[index]); /*-< 设置当前周期对应时间戳[1]给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	LongToChar(pTmStmp->NowRecvTCr, &VarArray[index]); /*-< 设置当前接收到发送方报文时钟给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

#ifndef RSSPI_SIMPLE_LINK_REFRESH /*是否定义简单链路宏开关*/

	LongToChar(pTmStmp->SseTC, &VarArray[index]); /*-< 设置SSE请求时周期号给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	LongToChar(pTmStmp->SseTn[0], &VarArray[index]); /*-< 设置SSE请求时的周期对应时间戳[0]给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	LongToChar(pTmStmp->SseTn[1], &VarArray[index]); /*-< 设置SSE请求时的周期对应时间戳[1]给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	LongToChar(pTmStmp->RecvSseTCe, &VarArray[index]); /*-< 设置SSE报文的对方时钟给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	LongToChar(pTmStmp->SeqEng[0], &VarArray[index]); /*-< 设置收到SSE报文时SEQENQ[0]给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	LongToChar(pTmStmp->SeqEng[1], &VarArray[index]); /*-< 设置收到SSE报文时SEQENQ[1]给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	VarArray[index++] = pTmStmp->NumSendSse; /*-< 设置发送SSE次数给链路数据,下标自增1*/

	LongToChar(pTmStmp->SsrTc, &VarArray[index]); /*-< 设置上次同步的周期数给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

#endif

	LongToChar(pTmStmp->NowSINIT_ADD_SID_XOR_Tn[0], &VarArray[index]); /*-< 设置当前的收到报文时SINITr AND [SIDr ^ Tr(n)] [0]给链路数据*/
	index += 4; /*-< 链路数据下标自增4*/

	LongToChar(pTmStmp->NowSINIT_ADD_SID_XOR_Tn[1], &VarArray[index]); /*-< 设置当前的收到报文时SINITr AND [SIDr ^ Tr(n)] [1]给链路数据*/
}

/**
 * @brief VarArray2LnkNodeInfo_WL 链路数据赋值链路节点
 * @param VarArray 链路数据 取值范围:字节数组
 * @param pNode 链路节点 取值范围:参考结构体:Lnk_Info_Node_Stru_WL
 */
static void VarArray2LnkNodeInfo_WL(const UINT8* VarArray, Lnk_Info_Node_Stru_WL* pNode)
{
	UINT16 index = 0; /*链路数据下标*/
	RsspLinkInfoStru_WL* pRsspLnkInfo = &pNode->RsspLinInfo; /*当前链路信息*/
	TimeStampStru_WL* pTmStmp = &pNode->RsspLinInfo.TimeStmp; /*当前链路时间戳*/

	index += 1; /*-< 跳过所在链路中下标*/

	pNode->CycleNum = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给周期号*/
	index += 4; /*-< 链路数据下标自增4*/

	pNode->ExeCycle = VarArray[index++]; /*-< 链路数据赋值给是否为执行周期,下标自增1*/

	pNode->HasRsdBeforeSseOrSsr = VarArray[index++]; /*-< 链路数据赋值给在生成SSE或者SSR之前是否有生成RSD,下标自增1*/

	pNode->RecvKeepHaltCycleNum = VarArray[index++]; /*-< 设置链路数据给接收保持Halt_WL状态周期数,下标自增1*/

	pNode->RecvKeepSendSseCycleNum = VarArray[index++]; /*-< 设置链路数据给接收保持SendSSE_WL状态周期数,下标自增1*/

	pNode->DestDevName = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给对方唯一ID*/
	index += 4; /*-< 链路数据下标自增4*/

	pNode->DestTypeId = ShortFromChar(&VarArray[index]); /*-< 链路数据赋值给对方类型ID*/
	index += 2; /*-< 链路数据下标自增2*/

	pNode->DestLogicId = ShortFromChar(&VarArray[index]); /*-< 链路数据赋值给对方逻辑ID*/
	index += 2; /*-< 链路数据下标自增2*/

	pNode->NodeStatus = VarArray[index++]; /*-< 链路数据赋值给节点可覆盖状态,下标自增1*/

	pRsspLnkInfo->LocalLogId = VarArray[index++]; /*-< 链路数据赋值给本方动态ID,下标自增1*/

	pRsspLnkInfo->DestLogId = VarArray[index++]; /*-< 链路数据赋值给对方动态ID,下标自增1*/

	pRsspLnkInfo->RecvLinkStatus = VarArray[index++]; /*-< 链路数据赋值给链路接受状态,下标自增1*/

	pRsspLnkInfo->SendLinkStatus = VarArray[index++]; /*-< 链路数据赋值给链路发送状态,下标自增1*/

	pRsspLnkInfo->NoRecvDataCycleNum = VarArray[index++]; /*-< 链路数据赋值给无数据周期数,下标自增1*/

	pRsspLnkInfo->NoAppDataCycleNum = VarArray[index++]; /*-< 链路数据赋值给无发送应用数据周期数,下标自增1*/

	pRsspLnkInfo->DestBsdAdd = (INT16)ShortFromChar(&VarArray[index]); /*-< 链路数据赋值给BSD地址*/
	index += 2; /*-< 链路数据下标自增2*/

	pRsspLnkInfo->RsspSrcAddr = ShortFromChar(&VarArray[index]); /*-< 链路数据赋值给RSSP源地址*/
	index += 2; /*-< 链路数据下标自增2*/

	pRsspLnkInfo->RsspDestAddr = ShortFromChar(&VarArray[index]); /*-< 链路数据赋值给RSSP目的地址*/
	index += 2; /*-< 链路数据下标自增2*/

	pTmStmp->TC = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给当前时间计数器*/
	index += 4; /*-< 链路数据下标自增4*/

	pTmStmp->LastLocalRecTC = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给上次收到报文本地时钟*/
	index += 4; /*-< 链路数据下标自增4*/

	pTmStmp->NowTn[0] = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给当前周期对应时间戳[0]*/
	index += 4; /*-< 链路数据下标自增4*/

	pTmStmp->NowTn[1] = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给当前周期对应时间戳[1]*/
	index += 4; /*-< 链路数据下标自增4*/

	pTmStmp->NowRecvTCr = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给当前接收到发送方报文时钟*/
	index += 4; /*-< 链路数据下标自增4*/

#ifndef RSSPI_SIMPLE_LINK_REFRESH /*是否定义简单链路宏开关*/

	pTmStmp->SseTC = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给SSE请求时周期号*/
	index += 4; /*-< 链路数据下标自增4*/

	pTmStmp->SseTn[0] = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给SSE请求时的周期对应时间戳[0]*/
	index += 4; /*-< 链路数据下标自增4*/

	pTmStmp->SseTn[1] = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给SSE请求时的周期对应时间戳[1]*/
	index += 4; /*-< 链路数据下标自增4*/

	pTmStmp->RecvSseTCe = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给SSE报文的对方时钟*/
	index += 4; /*-< 链路数据下标自增4*/

	pTmStmp->SeqEng[0] = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给收到SSE报文时SEQENQ[0]*/
	index += 4; /*-< 链路数据下标自增4*/

	pTmStmp->SeqEng[1] = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给收到SSE报文时SEQENQ[1]*/
	index += 4; /*-< 链路数据下标自增4*/

	pTmStmp->NumSendSse = VarArray[index++]; /*-< 链路数据赋值给发送SSE次数,下标自增1*/

	pTmStmp->SsrTc = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给上次同步的周期数*/
	index += 4; /*-< 链路数据下标自增4*/

#endif

	pTmStmp->NowSINIT_ADD_SID_XOR_Tn[0] = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给当前的收到报文时 SINITr AND [SIDr ^ Tr(n)] [0]*/
	index += 4; /*-< 链路数据下标自增4*/

	pTmStmp->NowSINIT_ADD_SID_XOR_Tn[1] = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给当前的收到报文时 SINITr AND [SIDr ^ Tr(n)] [1]*/
	index += 4; /*-< 链路数据下标自增4*/
}

 /*
*函数名:	CheckRecvDsuLnkInfoWl
*功能描述:	根据DSU取得接收方信息，检查与队列里的信息是否一致
*输入参数:	UINT16 LocalDevName	本方类型ID
*			const DataNode_WL *pNode	收到数据节点
*			const DSU_RSSP_LINK_RINFO_STRU_WL *pRecvLnkInfo	接收方信息
*			DSU_RSSP_INFO_STRU_WL *pDsuRsspi	RSSPI配置信息
*输入出参:	无
*输出参数:	无
*返回值:	1:成功,0:失败
*/
 static UINT8 CheckRecvDsuLnkInfoWl(UINT16 LocalDevName, const DataNode_WL *pNode, const DSU_RSSP_LINK_RINFO_STRU_WL *pRecvLnkInfo, DSU_RSSP_INFO_STRU_WL *pDsuRsspi)
 {
	 UINT8 rtn = 0;	/*返回值*/
	 UINT8 locType = 0;	/*本方类型*/
	 UINT8 locId = 0;	/*本方ID*/

	 if (NULL != pRecvLnkInfo)	/*输入参非空*/
	 {
		 DevName2TypeId_WL(LocalDevName, &locType, &locId);
		 if ((pRecvLnkInfo->DestName == pDsuRsspi->LocEmitterName) && (pRecvLnkInfo->SseAddr == pDsuRsspi->LocRsspiAddr) && (pNode->LocalLogId == locId))
		 {
			 /*收到数据对应的本方唯一ID正确*/
			 rtn = 1;
		 }
	 }

	 return rtn;
 }
 
 /*
*函数名:	CheckOutputDsuLnkInfoWl
*功能描述:	根据DSU取得发送方信息，检查与队列里的信息是否一致
*输入参数:	UINT16 LocalDevName	本方类型ID
*			const DataNode_WL *pNode	收到数据节点
*			const DSU_RSSP_LINK_SINFO_STRU_WL *pOutputLnkInfo 发送方信息
*			DSU_RSSP_INFO_STRU_WL *pDsuRsspi	RSSPI配置信息
*输入出参:	无
*输出参数:	无
*返回值:	1:成功,0:失败
*/
 static UINT8 CheckOutputDsuLnkInfoWl(UINT16 LocalDevName, const DataNode_WL *pNode, const DSU_RSSP_LINK_SINFO_STRU_WL *pOutputLnkInfo, DSU_RSSP_INFO_STRU_WL *pDsuRsspi)
 {
	 UINT8 rtn = 0;	/*返回值*/
	 UINT8 locType = 0;	/*本方类型*/
	 UINT8 locId = 0;	/*本方ID*/
	 UINT8 dstId = 0;	/*对方ID*/

	 if (NULL != pOutputLnkInfo)	/*输入参非空*/
	 {
		 DevName2TypeId_WL(LocalDevName, &locType, &locId);	/*本方设备ID*/
#ifdef RSSP_NO_HLHT
		 dstId = pOutputLnkInfo->DestName & 0xff;
#else
		 dstId = DquToDevId(pOutputLnkInfo->DestName, pDsuRsspi);	/*对方设备ID*/
#endif

		 if ((pOutputLnkInfo->DestName == pNode->DevName) && (pNode->LocalLogId == locId) && (pNode->DestLogId == dstId))
		 {
			 /*收到数据对应的对方设备ID正确*/
			 rtn = 1;
		 }
	 }

	 return rtn;
 }

/***********************************************************************
 * 方法名   :   CheckInputAddrWl
 * 功能描述 : 检查根据本方设备名称以及SSE地址 取得的本方作为接受信息是否正确。
 * 输入参数 : 
 *	参数名			类型							输入输出		描述
 *  ------------------------------------------------------------------------
 *  LocalDevName	UINT16							IN				本方标识符
 *	SrcAddr			UINT16							IN				源地址
 *  pRecvLnkInfo	const DSU_RSSP_LINK_RINFO_STRU_WL*	IN				接受信息
 *
 * 返回值   : UINT8  1：正常返回  0：错误返回
 ***********************************************************************/
static UINT8 CheckInputAddrWl(UINT32 LocalDevName,UINT16 SrcAddr,
					 const DSU_RSSP_LINK_RINFO_STRU_WL *pRecvLnkInfo)
{
	UINT8 ret = 0;
	/* Del 20130802 S */
	/*UINT8 Type = 0, Id =0;

	DevName2TypeId_WL(LocalDevName,&Type,&Id);*/		/* 取得设备类型 和 设备Id */
    /* 删除多余的代码 wangpeipei Del E */

	/*ADD 20130802 */
	if(pRecvLnkInfo == NULL)
	{
        return ret;
	}
	/* 接收方的SSE地址是否等于本方源地址，如果不是说明应用给出的地址有误 */
	if(SrcAddr != pRecvLnkInfo->SseAddr)
	{
		return ret;
	}

	/* 
	 * 对方标识符和本方的标识符不相等 则应用给出地址有误
	 */
	if(LocalDevName != pRecvLnkInfo->DestName)
	{
		return ret;
	}

	ret = 1;	/* 检查正常 */
	return ret;
}

/***********************************************************************
 * 方法名   :   SetNodeParamWl
 * 功能描述 : 从配置库取出来的通信节点基本信息设置到指定的设备节点基本信息结构体里面。
 * 输入参数 : 
 *	参数名				类型							输入输出	描述
 *  --------------------------------------------------------------------------
 *	pRecvDsuLnkInf		const DSU_RSSP_LINK_RINFO_STRU_WL*	 IN			接受信息
 *  pOutputDsuLnkInf	const DSU_RSSP_LINK_SINFO_STRU_WL*	 IN			发送信息
 *	pRsspLnkInfo		RsspLinkInfoStru_WL*				 INOUT		链路基本信息结构体
 *
 * 返回值   : UINT8  1：正常返回  
 ***********************************************************************/
static UINT8 SetNodeParamWl(const DSU_RSSP_LINK_RINFO_STRU_WL* pRecvDsuLnkInf, 
						  const DSU_RSSP_LINK_SINFO_STRU_WL* pOutputDsuLnkInf, 
						  NodeParamInfoStru_WL *pNodeParam)
{
	UINT8 chan = 0;			/* 信号道 */
	UINT8 index = 0;
	UINT8 ret = 0;

	if((pRecvDsuLnkInf == NULL)||(pOutputDsuLnkInf== NULL))
	{
		ret = 0;
	}
	else
	{
		for(chan = 0; chan < 2; chan++)
		{
			/* 发送节点基本信息 */
			pNodeParam->SIDe[chan] = pOutputDsuLnkInf->SID_NUMBER_R[chan];				/* 接收方SID */
			pNodeParam->SIDr[chan] = pOutputDsuLnkInf->SID_NUMBER_E[chan];				/* 发送方SID */	  
			pNodeParam->SINIT[chan] = pOutputDsuLnkInf->SINIT_NUMBER[chan];				/* 表示首个SINIT */
			pNodeParam->DATAVER[chan] = pOutputDsuLnkInf->DATAVER_1_Number[chan];		/* DATAVER */
			pNodeParam->NumDataVer[chan] = pOutputDsuLnkInf->DATANUM[chan];	 			/* Data 版本号 */
			
			/* 离线参数值 */
			pNodeParam->PREC_FIRSTSINIT[chan] = pRecvDsuLnkInf->PREC_FIRSTSINIT[chan];	/* 离线参数PREC_FIRSTSINIT */
			for( index = 0; index < DSURSR_MAX_K_NUM_WL; index++)
			{
				pNodeParam->PREC_SINIT_K[chan][index] = pRecvDsuLnkInf->PREC_SINIT_K[chan][index];			/* 离线参数PREC_SINIT  */					
				pNodeParam->TSD_POST_RXDADA_K[chan][index] = pRecvDsuLnkInf->POST_RXDADA_K[chan][index];	/* 离线参数 BSD解码固定值 */
			}
		}

		/* 接收方基本信息 */
		pNodeParam->DLost = pRecvDsuLnkInf->DLost;						/* 最大无数据周期数 */
		pNodeParam->SSDelay  = pRecvDsuLnkInf->WSsrOut;					/* 规定时间（SSDelay） */
		pNodeParam->AntiDelayCount = pRecvDsuLnkInf->AntiDelayCount;	/* 定期同步周期数 */
		pNodeParam->Tout  = pRecvDsuLnkInf->TOut ;						/* BSD报文超时 */
		pNodeParam->MaxLost = pRecvDsuLnkInf->MaxLost;					/* 最大丢失报文数 */
		
	}
	ret = 1;
	return (UINT8)1;
}

/***********************************************************************
 * 方法名   :   AdjustLnkCycle
 * 功能描述 :	根据指定本方类型、周期号、当前链路，调整当前链路周期号并设置是否为执行周期。
 * 输入参数 :
 *	参数名		类型					输入输出	描述
 *  -----------------------------------------------------------
 *	localType	UINT8					IN			本方类型
 *	cycleNum	UINT32					IN			周期号
 *	lnkNode		Lnk_Info_Node_Stru_WL*	IN			链路节点
 *
 * 返回值   :	无
 ***********************************************************************/
void AdjustLnkCycle(UINT8 localType, UINT32 cycleNum, Lnk_Info_Node_Stru_WL* lnkNode)
{
	if (lnkNode != NULL)
	{
		if (((RSSP_TYPE_VOBC_WL == localType) || (RSSP_TYPE_VOBC_BACK_WL == localType)) && (RSSP_TYPE_ATS_WL == (lnkNode->DestTypeId / 256)))	/*VOBC发往ATS*/
		{
			if (0 == (cycleNum % VOBC_ATS_CYCLENUM_MULTIPLE))	/*周期号倍数,调整链路周期号并可执行*/
			{
				lnkNode->ExeCycle = 1;
			}
			else  /*非周期号倍数,不执行*/
			{
				lnkNode->ExeCycle = 0;
			}
		}
		else if ((RSSP_TYPE_AOM_WL == localType) && (RSSP_TYPE_ATS_WL == (lnkNode->DestTypeId / 256)))	/*AOM发往ATS*/
		{
			if (0 == (cycleNum % AOM_ATS_CYCLENUM_MULTIPLE))	/*周期号倍数,调整链路周期号并可执行*/
			{
				lnkNode->ExeCycle = 1;
			}
			else  /*非周期号倍数,不执行*/
			{
				lnkNode->ExeCycle = 0;
			}
		}
		else /*否则,不用调整链路周期可执行*/
		{
			lnkNode->ExeCycle = 1;
		}
	}
}

/*--------------------------------------------------------------------
 * 链路管理模块内部函数申明 End
 *--------------------------------------------------------------------*/

#ifdef __cplusplus
}
#endif



