ldpsess.c

技术文件名称：MPLSv1.0软件模块测试规程

    if (ii == LDP_FALSE)    return LDP_FALSE;
    return  LDP_TRUE;
}

/*      发送KEEPALIVE消息，成功返回LDP_TRUE，不成功返回LDP_FALSE */
short    SendKeepalMsg(mplsLdpSession_t * session)
{    
    long                    ii;
	 
    #if 0
    /* set keepalive send timer */
	MPLS_SET_TIMER(session->keepAliveHoldTime/3,
					(void *)SendKeepalMsg,
					session,
					ldptime_q,
					session->keepalive_send_timerid);
	#endif
	
	session->keepalive_send_timerid = session->keepAliveHoldTime/3;
	MPLS_MEMSET(&(ldp_snd_msg.keepAliveMsg),0,sizeof(mplsLdpKeepAlMsg_t));
    InitkeepalMsg(&(ldp_snd_msg.keepAliveMsg));
    ldp_snd_msg.keepAliveMsg.baseMsg.msgId        = messageId[KEEPALIVE_M];
    AddMsgId(KEEPALIVE_M);
                
    ii = SendTcpMsg(session,MPLS_KEEPAL_MSGTYPE,&(ldp_snd_msg.keepAliveMsg));
    if (ii == LDP_FALSE)    return LDP_FALSE;
    return  LDP_TRUE;

}	


/*      发送INIT和KEEPALIVE消息,成功返回LDP_TRUE，不成功返回LDP_FALSE   */
/* sbp 2002-2-4 change loop detection from global to one interface */
short    SendInitKeepalMsg(mplsLdpSession_t * session)
{    
    long                    ii,jj;
	unsigned short          pduSize;
	long 				    sizeTemp;
	mplsLdpHeader_t         pduHeader;	
	mplsLdpEntity_t			*pEntity = MPLS_NULL;
	
	pEntity = ldp_session_search_entity(session);
	if(pEntity == MPLS_NULL)
		return LDP_FALSE;
	
	/* 构造INIT消息*/
	MPLS_MEMSET(&(ldp_snd_msg.initMsg),0,sizeof(mplsLdpInitMsg_t));
    InitInitMsg( &(ldp_snd_msg.initMsg));
    ldp_snd_msg.initMsg.baseMsg.msgId        = messageId[INIT_M];
    AddMsgId(INIT_M);
    
    ldp_snd_msg.initMsg.csp.protocolVersion  = (unsigned short)(pEntity->protocolVersion);
    ldp_snd_msg.initMsg.csp.holdTime         = (unsigned short)(pEntity->keepAliveHoldTimer);
    ldp_snd_msg.initMsg.csp.flags.flags.lad  = (unsigned short)(pEntity->labelDistributionMethod);
    /* sbp 2002-2-4 change loop detection from global to one interface */
    ldp_snd_msg.initMsg.csp.flags.flags.ld   = pEntity->loopDetectionCapable;
    ldp_snd_msg.initMsg.csp.flags.flags.pvl  = pEntity->pathvectorlimit;
    ldp_snd_msg.initMsg.csp.maxPduLen        = pEntity->maxPduLength;
    ldp_snd_msg.initMsg.csp.rcvLsrAddress    = session->peerLdpId.lsrAddress;
    ldp_snd_msg.initMsg.csp.rcvLsId          = session->peerLdpId.labelSpace;

    if(ldp_snd_msg.initMsg.csp.flags.flags.lad == DOWNSTREAMONDEMAND)
    {
    	ldp_snd_msg.initMsg.aspExists                      = 1;
		ldp_snd_msg.initMsg.asp.baseTlv.flags.flags.uBit   = 0;
		ldp_snd_msg.initMsg.asp.baseTlv.flags.flags.fBit   = 0;
		ldp_snd_msg.initMsg.asp.baseTlv.flags.flags.type   = MPLS_ASP_TLVTYPE;
		ldp_snd_msg.initMsg.asp.baseTlv.length     	    = MPLS_ASPFIXLEN + 8;
		ldp_snd_msg.initMsg.asp.flags.flags.res            = 0;
		
	    ldp_snd_msg.initMsg.asp.flags.flags.mergeType  = pEntity->atmMergeCap;
	    ldp_snd_msg.initMsg.asp.flags.flags.numLblRng  = pEntity->ifNumber;
	    ldp_snd_msg.initMsg.asp.flags.flags.dir        = pEntity->atmVcDirectionality;
    
	    /*对 atm的labelrangcomponents进行赋值 */
	    jj = 0;
	    for (ii=0 ; ii< allInterface.num; ii++)
	        if (allInterface.interface[ii].ifIndex == session->ifIndex)
	        {
	            memcpy(&(ldp_snd_msg.initMsg.asp.lblRngList[jj]),&(allInterface.interface[ii].conflblRngList),\
	                        sizeof(mplsLdpAtmLblRng_t));
	            break;
	        }
    }
            
    /* 构造PDU头部 */
    pduSize = MPLS_LDP_HDRSIZE;										
	pduHeader.protocolVersion = pEntity->protocolVersion;							
	pduHeader.lsrAddress = pEntity->ldpId.lsrAddress;
	pduHeader.labelSpace = pEntity->ldpId.labelSpace;   
	
	/* 编码 */
	sizeTemp = Mpls_encodeLdpInitMsg(&(ldp_snd_msg.initMsg),\
						pduBuffer + pduSize, (MAX_PDU_LENGTH - pduSize));
    if (sizeTemp < 0)
    {
        printf("Init message encode error!\n");											
        return LDP_FALSE;
    }
    
    /*构造KEEPALIVE消息*/
    MPLS_MEMSET(&(ldp_snd_msg.keepAliveMsg),0,sizeof(mplsLdpKeepAlMsg_t));
    InitkeepalMsg( &(ldp_snd_msg.keepAliveMsg));
    ldp_snd_msg.keepAliveMsg.baseMsg.msgId        = messageId[KEEPALIVE_M]; 
    AddMsgId(KEEPALIVE_M);
    
	pduSize += sizeTemp;
	
    sizeTemp = Mpls_encodeLdpKeepAliveMsg(&ldp_snd_msg.keepAliveMsg,\
						pduBuffer + pduSize, (MAX_PDU_LENGTH - pduSize));
    if (sizeTemp < 0)   
    {
        printf("Keepalive message encode error!\n");											
        return LDP_FALSE;
    }
	pduSize += sizeTemp;
				
	pduHeader.pduLength	= (unsigned short)(pduSize - MPLS_MSGIDFIXLEN);
	sizeTemp = Mpls_encodeLdpMsgHeader(&pduHeader, \
	                    pduBuffer, MPLS_LDP_HDRSIZE); 
	if (sizeTemp < 0)  
	{
	    printf("pdu Header encode error!\n");
	    return LDP_FALSE;
	}
	
	/* 发送TCP包 */
	udptcpMsg.ProtType	    = PROT_TCP;
	udptcpMsg.LocalIpaddr 	= session->localIpaddr;
	udptcpMsg.PeerIpaddr 	= session->peerIpaddr;
	udptcpMsg.LocalPort 	= session->LocalPort;
	udptcpMsg.PeerPort 	    = session->PeerPort;
	memcpy(udptcpMsg.pdu,pduBuffer,pduSize);
	udptcpMsg.pdulen		= pduSize;
	sizeTemp                = pduSize + LDPMSG_COMMHEADSIZE;

  /*	MPLS_PSEND(MSG_SEND_REQ,&udptcpMsg,sizeTemp,udptcpPid);  */
    if(eppc_init_status()) 
	{
	    send_ldpmsg_to_eppc(3, &udptcpMsg, 0);
	}
	
	#ifdef SESSION_DEBUG
		#ifdef __BGS10_MPLS_DEBUG
		    // szh mod in 2001-7-10 10:33
		    printf(" !!!MODULE :%d send message on tcp link localIpaddr %x,PeerIpaddr %x,LocalPort %d,PeerPort %d !!!",
		        selfLdpPid.module,udptcpMsg.LocalIpaddr,udptcpMsg.PeerIpaddr,udptcpMsg.LocalPort,udptcpMsg.PeerPort);
		#endif
	#endif
	#if 0
    /* set keepalive send timer */
	MPLS_SET_TIMER(session->keepAliveHoldTime/3,
					(void *)SendKeepalMsg,
					session,
					ldptime_q,
					session->keepalive_send_timerid);
	#endif
	session->keepalive_send_timerid = session->keepAliveHoldTime/3;
	return LDP_TRUE;		
	
}
	

/*      发送Address和Address Withdraw消息，成功返回LDP_TRUE，不成功返回LDP_FALSE */
short  SendAdrMsg(mplsLdpSession_t * session, unsigned long flag)
{    
    long                    ii,jj,num ;
    unsigned short                  ifIndex;
    unsigned short                  loop, mm;
	
	mm = 0xffff;
	for (loop=0; loop<allEntity.num; loop++)
        if ((memcmp(&(allEntity.entity[loop].ldpId),&(session->entityLdpId),\
        	MPLS_LDPIDLEN) == 0)&&(allEntity.entity[loop].ifArray == session->ifIndex))
        {
            mm = loop;
            break;
        }
    if(mm == 0xffff)
    {
        DEBUG_OUT(DEBUG_OWNER_MPLS, DEBUG_LEVEL_MPLS_SESSION,"====Session %d,SendAdrMsg,Module:%d ProcTcpConRetry, Entity LDPId not match====\n",session->ifIndex,
    		        selfLdpPid.module);
        printf("====Session %d,Module:%d ProcTcpConRetry, Entity LDPId not match====\n",session->ifIndex,
    		        selfLdpPid.module);
        return LDP_FALSE;
    }
	
    InitAdrMsg(&(ldp_snd_msg.addrMsg),flag);
    ldp_snd_msg.addrMsg.baseMsg.msgId        = messageId[ADDR_M];
    AddMsgId(ADDR_M);
    
    num = allEntity.entity[mm].ifNumber;
    for (ii=0; ii<num; ii++)
    {
        ifIndex = allEntity.entity[mm].ifArray;
        for (jj=0; jj<allInterface.num; jj++)
            if (allInterface.interface[jj].ifIndex==ifIndex)
            {
                ldp_snd_msg.addrMsg.addressList.address[ii] = allInterface.interface[jj].ifIpAddress;
                break;    
            }
    }    
    ldp_snd_msg.addrMsg.addressList.baseTlv.length = (unsigned short)(MPLS_ADDFAMFIXLEN + num*MPLS_IPv4LEN);
    ldp_snd_msg.addrMsg.baseMsg.msgLength = 0;
    ii = SendTcpMsg(session,MPLS_ADDR_MSGTYPE,&(ldp_snd_msg.addrMsg));
    if (ii == LDP_FALSE)    return LDP_FALSE;
    return  LDP_TRUE;
    
}	

/******************************************************************************/
/*function:     DelTmid                                                      */
/*Author:       hu.yonghong                                                   */
/*decription:                                                                 */
/*				kill and delete session tmid								  */
/******************************************************************************/
void DelTmid( mplsLdpSession_t * session )
{
	int  		rtcode1,rtcode2;;
	
	#if 0
	/* delete & kill keepAlive send timer */
	if(session->keepalive_send_timerid > 0)
	{
		MPLS_CLEAR_TIMER(session->keepalive_send_timerid,ldptime_q,rtcode1);
		session->keepalive_send_timerid = 0;
	}
	#endif
	/* delete keepAlive maintain timer */
	if(session->life_timerid > 0)
	{
		MPLS_CLEAR_TIMER(session->life_timerid,ldptime_q,rtcode2);
		session->life_timerid = 0; 
	}
	return;
}

/******************************************************************************/
/*function:     ProcCloseSes                                                    */
/*Author:       weng.qing                                                     */
/*decription:                                                                 */
/*				kill and delete session tmid								  */
/*              Send to PP TCP Release Request,                               */
/*              Transit Session state to TCP_CONNECT_AWAITED,                 */
/*              Transit Session subState to NONIDLE,                          */
/*              set TCP Connect timer, time is 15 seconds                     */
/******************************************************************************/
void ProcCloseSes(mplsLdpSession_t * session,unsigned long statusCode,unsigned long msgId, unsigned short msgType)
{
    switch(statusCode)
    {
    	case SHUT_DOWN:
		    
		    #ifdef SESSION_DEBUG
    		    #ifdef __BGS10_MPLS_DEBUG
    				printf("========MODULE :%d  SEND NOTIFMSG =======\n",
    				        selfLdpPid.module);
    			#endif
			#endif
			
		    sndnotifymsgproc(session,SHUT_DOWN,0,0);      
    		break;
    	default:
    		
    		#ifdef SESSION_DEBUG
    		    #ifdef __BGS10_MPLS_DEBUG
				printf("========MODULE :%d  SEND NOTIFMSG =======\n",selfLdpPid.module);
			    #endif
			#endif
    		sndnotifymsgproc(session,statusCode,msgId,msgType);  	
    		break;
    }
    /* close tcp,trsnsit state to TCP_RELEASE_AWAITED */
    SendTcpRel(session);

}


/******************************************************************************/
/*function:     delPeerTable                                             	  */
/*Author:       weng.qing                                                     */
/*decription:                                                                 */
/*              delete peer table                                             */
/******************************************************************************/
short delPeerTable( mplsLdpSession_t * session )
{
    ldpMibPeerIndexReq_t       peerIndex;
	mplsLdpPeer_t              *peer = MPLS_NULL;
	
	peerIndex       = session->peerLdpId;
	peer = (mplsLdpPeer_t *)MibPeer(&peerIndex, LDP_DELETE);
	if (peer == MPLS_NULL)
	{
	    return LDP_FALSE;
	}
	else
	{
	    return LDP_TRUE;
	}
}

/******************************************************************************/
/*function:     delPeerAddress Table                                          */
/*Author:       weng.qing                                                     */
/*decription:                                                                 */
/*              delete peer table                                             */
/******************************************************************************/
short delPeerAddrTable( mplsLdpSession_t * session )
{
    ldpMibPeerAddrIndexReq_t	 adrIndex;
	sessionPeerAddr_t            *peerAddr = MPLS_NULL;
	short 			i;
	
	adrIndex.sessionIndex       = session->index;
	adrIndex.indexFlag			= 3;
	peerAddr = (sessionPeerAddr_t *)MibPeerAddr(&adrIndex, LDP_DELETE);
	if (peerAddr == MPLS_NULL)
	{
	    return LDP_FALSE;
	}
	else
	{
	    return LDP_TRUE;
	}
}

/******************************************************************************/
/*function:     checkSessionHello                                             */
/*Author:       weng.qing      hu.yonghong                                    */
/*decription:                                                                 */
/*              check if session have hello adjacency,                        */
/*              if no,  delete session                                        */
/*              else    retry tcp connect                                     */
/******************************************************************************/