lcm_drv.c

abstract rtos

                
                edrv_recv_pkt( mb, &addr, tcpflag, tcpSeq, tcpAck );
            }
            else
            {
                edrv_recv_tcp_signal( mb, &addr, tcpflag, tcpSeq, tcpAck );
            }
        }
        else
        {
            aping_hook4lcm( mb->data, &addr, tcpflag );
            pL3Msg = (L3_MSG_HEAD_S*)msg_push( mb, L3_MSG_HEAD_LEN );
            pL3Msg->srcProcessorId  = LOCAL_PROCESSOR_ID;
            pL3Msg->srcMpe  = dstMpe;
            pL3Msg->dstProcessorId  = LOCAL_PROCESSOR_ID;
            pL3Msg->dstMpe  = dstMpe;
            pL3Msg->ulSize  = mb->len - L3_MSG_HEAD_LEN;

    		mb->tail[0] = 0;

            MSG_QUE_SEND( dstMpe, mb, MSG_PRIO_NORMAL );
        }
#endif
        
        aos_dmem_free( (VOID*)pstMBuf );
#endif
    }

}





void if_p2p_send_packet(MBUF_S * mbuf)
{
    ROUTE_S	    route;
    IFNET_S	    *ifp;
    U32  ulDstIp, nexthop;
    IP_S            *ip;

    if(AOS_ADDR_INVALID(mbuf))
    {
        return;
    }

    ip = MBUF_MTOD(mbuf, IP_S*);
    aos_memcpy(&ulDstIp, &ip->ip_stDst.s_ulAddr, 4);

    ip->ip_usId   = AOS_HTONS(g_usIpId);
    if( g_bQosDscpEnable )
    {
		ip->ip_chTOS = g_stQoS[DSCP_SIGNAL_ID];
    }

    ip->ip_usSum = 0;
    ip->ip_usSum = rtp_ip_cksum( (U8*)ip, sizeof(IP_S) );

    g_stIpStat.ips_ulLocalOut++;
	g_usIpId++;


    ((SOCKADDRIN_S *)&(route.ro_stDst))->sin_stAddr.s_ulAddr = ulDstIp;
    rt_alloc(&route);
    if (NULL == route.ro_pRt)
    {
		mbuf_destroy(mbuf);
		return;
    }

	ifp = if_get_if_by_index(route.ro_pRt->rt_ulIfIndex);
	if (NULL == ifp || NULL == ifp->if_pfOutput)
	{
		mbuf_destroy(mbuf);
		return;
	}
	if (ifp->if_ulPhyType == PHY_LOOP)
	{
		mbuf_destroy(mbuf);
		return;
	}

	MBUF_ASSIGN_TAG_NETWORK_TYPE(mbuf, AF_INET);
	MBUF_ASSIGN_SEND_IFNET_INDEX(mbuf, route.ro_pRt->rt_ulIfIndex);

	if (RT_FIELD_FLAGS(route.ro_pRt) & RTF_GATEWAY)
	{
		nexthop = RT_FIELD_GATEWAY(route.ro_pRt);
	}
	else
	{
		nexthop = ulDstIp;
	}

	MBUF_GET_TAG_NETWORK_IP_PTR(mbuf)->ulNextHopIpAddress = nexthop;

    NAT_SET_FLAG(mbuf, NAT_TSF);

#if( CONFIG_BOARD_GMPU == TRUE )
	if (ifp->if_ulPhyType == PHY_LOOP)
	{
        ENQUEUE_PF pFun= NULL;
        IFNET_S * pIfp;

        pIfp = g_pstIfnet[SERVICE_ETHNET_PORT];
        if(pIfp->if_ulIpAddr == ulDstIp)
        {
        	MBUF_ASSIGN_RECEIVE_IFNET_INDEX(mbuf, pIfp->if_ulIfIndex);
        }
        else
        {
            pIfp = g_pstIfnet[NMS_ETHNET_PORT];
            if(pIfp->if_ulIpAddr == ulDstIp)
            {
            	MBUF_ASSIGN_RECEIVE_IFNET_INDEX(mbuf, pIfp->if_ulIfIndex);
            }
            else
            {
            	MBUF_ASSIGN_RECEIVE_IFNET_INDEX(mbuf, route.ro_pRt->rt_ulIfIndex);
            }
        }

        if( eth_is_rapid_pkt(mbuf, &pFun))
        {
            (*pFun)(mbuf);
        }
        else
        {
            mbuf_destroy(mbuf);
        }
		return;
	}
#endif

	if (ifp->if_pfLLCOutput(mbuf))
	{
		
	}
}

VOID lcm_rapid_send_to_eth_no_wrapper( U16 src_udp_port, struct msg_blk *mb, VOID *v_addr )
{
    IP_S            *ip;
    UDPHDR_S        *udp;

    MBUF_S          *mbuf;
    U32             src_ip,nexthop;
    ROUTE_S	    route;
    IFNET_S	    *ifp;
    SOCKADDRIN_S    *addr = (SOCKADDRIN_S*)v_addr;
    U8  *cp;


    ((SOCKADDRIN_S *)&(route.ro_stDst))->sin_stAddr.s_ulAddr = addr->sin_stAddr.s_ulAddr;
    rt_alloc(&route);
    if (NULL == route.ro_pRt)
    {
        aos_dmem_free( (VOID*)mb->head );
        msg_free(mb);
		return;
    }

	ifp = if_get_if_by_index(route.ro_pRt->rt_ulIfIndex);
	if (NULL == ifp || NULL == ifp->if_pfOutput)
	{
        aos_dmem_free( (VOID*)mb->head );
        msg_free(mb);
		return;
	}

    mbuf = (MBUF_S*)aos_dmem_alloc( MPE_LCM, SID_MBUF, MBUF_MBUF_SIZE );
    if( NULL == mbuf )
    {
        aos_dmem_free( (VOID*)mb->head );
        msg_free(mb);
        return;
    }
#if( CONFIG_BOARD_EIA == TRUE )
    src_ip = if_get_out_ipaddr();
#else
    src_ip = ifp->if_ulIpAddr;
    if (ifp->if_ulPhyType == PHY_LOOP)
    {
        src_ip = addr->sin_stAddr.s_ulAddr;
    }
#endif


    udp = (UDPHDR_S*)msg_push( mb, sizeof(UDPHDR_S) );
    udp->uh_sULen   = (S16)AOS_HTONS( (U16)mb->len );
    udp->uh_usSPort = AOS_HTONS( src_udp_port );
    udp->uh_usDPort = addr->sin_usPort; 
    udp->uh_usSum   = 0;
    udp->uh_usSum   = rtp_udp_checksum( (U8*)udp, src_ip, addr->sin_stAddr.s_ulAddr, (U16)mb->len );

    ip  = (IP_S*)msg_push( mb, sizeof(IP_S) );
    ip->ip_chHLen = 5;
    ip->ip_chVer  = 4;
    ip->ip_chTOS  = 0;		
    ip->ip_usLen  = AOS_HTONS((U16)mb->len);
    ip->ip_usId   = AOS_HTONS(g_usIpId);
    ip->ip_usOff  = 0;
    ip->ip_chTTL  = 128;
    ip->ip_chPr   = 0x11; 
    ip->ip_usSum  = 0;

    g_stIpStat.ips_ulLocalOut++;
	g_usIpId++;

    cp = (U8*)&(ip->ip_stSrc.s_ulAddr);
    aos_memcpy( cp , (U8*)&src_ip , 4 ) ;

    cp = (U8*)&(ip->ip_stDst.s_ulAddr);
    aos_memcpy( cp , (U8*)&(addr->sin_stAddr.s_ulAddr) , 4 ) ;

    if( g_bQosDscpEnable )
    {
		ip->ip_chTOS = g_stQoS[DSCP_SIGNAL_ID];
    }

    ip->ip_usSum = rtp_ip_cksum( (U8*)ip, sizeof(IP_S) );

    mbuf->ulMbufMagic = MBUF_MAGIC_NUMBER;
    mbuf->stDataBlockDescriptor.ulDBMagic = DBES_MAGIC_NUMBER;
    mbuf->stDataBlockDescriptor.ulType = MBUF_TYPE_DATA;
    mbuf->stDataBlockDescriptor.ulOption = 0;
    mbuf->stDataBlockDescriptor.pstNextDataBlockDescriptor = NULL;

    mbuf->stDataBlockDescriptor.pucDataBlock = mb->head;
    mbuf->stDataBlockDescriptor.ulDataBlockLength = mb->truelen;
    mbuf->stDataBlockDescriptor.pucData = mb->data;
    mbuf->stDataBlockDescriptor.ulDataLength = mb->len;

    mbuf->ulTotalDataLength = mb->len;
    mbuf->ulDataBlockNumber = 1;
    mbuf->pstNextMBuf = NULL;
    
    (VOID)aos_memset( (VOID *) (& mbuf->stUserTagData), 0 , sizeof(MBUF_USERTAGDATA_S));

    msg_free(mb);



	MBUF_ASSIGN_TAG_NETWORK_TYPE(mbuf, AF_INET);
	MBUF_ASSIGN_SEND_IFNET_INDEX(mbuf, route.ro_pRt->rt_ulIfIndex);

	if (RT_FIELD_FLAGS(route.ro_pRt) & RTF_GATEWAY)
	{
		nexthop = RT_FIELD_GATEWAY(route.ro_pRt);
	}
	else
	{
		nexthop = addr->sin_stAddr.s_ulAddr;
	}

	MBUF_GET_TAG_NETWORK_IP_PTR(mbuf)->ulNextHopIpAddress = nexthop;

    NAT_SET_FLAG(mbuf, NAT_TSF);

#if( CONFIG_BOARD_GMPU == TRUE )
	if (ifp->if_ulPhyType == PHY_LOOP)
	{
        ENQUEUE_PF pFun= NULL;
        IFNET_S * pIfp;

        pIfp = g_pstIfnet[SERVICE_ETHNET_PORT];
        if(pIfp->if_ulIpAddr == addr->sin_stAddr.s_ulAddr)
        {
        	MBUF_ASSIGN_RECEIVE_IFNET_INDEX(mbuf, pIfp->if_ulIfIndex);
        }
        else
        {
            pIfp = g_pstIfnet[NMS_ETHNET_PORT];
            if(pIfp->if_ulIpAddr == addr->sin_stAddr.s_ulAddr)
            {
            	MBUF_ASSIGN_RECEIVE_IFNET_INDEX(mbuf, pIfp->if_ulIfIndex);
            }
            else
            {
            	MBUF_ASSIGN_RECEIVE_IFNET_INDEX(mbuf, route.ro_pRt->rt_ulIfIndex);
            }
        }

        #if (AOS_INCLUDE_SERVICE_RTPRTCP == TRUE)
        if(ht_isrtp(AOS_NTOHS(addr->sin_usPort)))
        {
            if((AOS_NTOHS(addr->sin_usPort) & 0x1) == 0x00
    		&& ht_mux_tunnel_rapid_fwd(mbuf->stDataBlockDescriptor.pucData
    								, mbuf->stDataBlockDescriptor.ulDataLength
    								, AOS_NTOHS(addr->sin_usPort)
    								, src_udp_port))
        	{
                aos_dmem_free(mbuf);
        		return ;
        	}
        }
        #endif

        if( eth_is_rapid_pkt(mbuf, &pFun))
        {
            (*pFun)(mbuf);
        }
        else
        {
            mbuf_destroy(mbuf);
        }
		return;
	}
#endif

	if (ifp->if_pfLLCOutput(mbuf))
	{
		
	}
}

VOID lcm_rapid_send_to_eth( U16 src_udp_port, struct msg_blk *mb, VOID *v_addr )
{

    MBUF_S          *mbuf;
    SOCKADDRIN_S    *addr = (SOCKADDRIN_S*)v_addr;

    if(0 == addr->sin_stAddr.s_ulAddr
    || 0 == AOS_NTOHS(addr->sin_usPort)
    || U32_BUTT == addr->sin_stAddr.s_ulAddr
    || U16_BUTT == AOS_NTOHS(addr->sin_usPort))
    {
        aos_dmem_free( (VOID*)mb->head );
        msg_free(mb);
        return;
    }

#if (CONFIG_BOARD_EIA == TRUE)
	if(ht_istunnelmode())
	{
		ht_send_msg_rapid(mb, src_udp_port, AOS_NTOHS(addr->sin_usPort));
	    return;
    }
#if( AOS_INCLUDE_SERVICE_P2P_NN == TRUE )
    if( dev_iseig( ) )
    {
        
        MBUF_CREATE_BY_DATA_BLOCK( mbuf, mb->head, mb->truelen, mb->data, mb->len, 0, MPE_LCM );
        if( NULL != mbuf )
        {
            p2p_trans_send_signal( src_udp_port, addr, mbuf );
        }
        else
        {
            aos_dmem_free( (VOID*)mb->head );
        }
        msg_free( mb );
        return;
    }
#endif
#endif

#if(CONFIG_BOARD_GMPU == TRUE)
	if((addr->sin_stAddr.s_ulAddr == AOS_HTONL(0x7F000001)
	|| addr->sin_stAddr.s_ulAddr == if_get_out_ipaddr()))
	{
        if( p2p_is_p2p_logic_port(AOS_NTOHS(addr->sin_usPort)) )
        {
            MBUF_CREATE_BY_DATA_BLOCK( mbuf, mb->head, mb->truelen, mb->data, mb->len, 0, MPE_LCM );
            if( NULL != mbuf )
            {
                p2p_trans_send_signal( src_udp_port, addr, mbuf );
            }
            else
            {
                AOS_ASSERT(0);
                aos_dmem_free( (VOID*)mb->head );
            }
            msg_free( mb );
            return;
        }
        else if( ht_istunneludp(AOS_NTOHS(addr->sin_usPort)) )
        {
			ht_send_msg_rapid(mb, src_udp_port
							, AOS_NTOHS(addr->sin_usPort));
			return;
        }
	}
#endif

    lcm_rapid_send_to_eth_no_wrapper( src_udp_port, mb, v_addr );
}

VOID lcm_tcp_rapid_send_to_eth_no_warpper( U16 src_port, U32 seq, U32 ack, struct msg_blk *mb, VOID *v_addr )
{
    SOCKADDRIN_S *addr = (SOCKADDRIN_S*)v_addr;
    MBUF_S       *mbuf;
    TCPIPHDR_S   *tcpip;
	IP_S         *ip;
    IFNET_S	     *ifp;
	ROUTE_S	      route;
	U32           len;
    U32           srcip, nexthop;
    U32           ulResult;

    if(NULL == mb)
    {
		return;
    }
    if(0 == addr->sin_stAddr.s_ulAddr
    || 0 == AOS_NTOHS(addr->sin_usPort)
    || U32_BUTT == addr->sin_stAddr.s_ulAddr
    || U16_BUTT == AOS_NTOHS(addr->sin_usPort))
    {
        aos_dmem_free( (VOID*)mb->head );
        msg_free(mb);
        return;
    }

    
    ((SOCKADDRIN_S *)&(route.ro_stDst))->sin_stAddr.s_ulAddr = addr->sin_stAddr.s_ulAddr;
    rt_alloc(&route);
    if (NULL == route.ro_pRt)
    {
        aos_dmem_free( (VOID*)mb->head );
        msg_free(mb);
		return;
    }

	ifp = if_get_if_by_index(route.ro_pRt->rt_ulIfIndex);
	if (NULL == ifp || NULL == ifp->if_pfOutput)
	{
        aos_dmem_free( (VOID*)mb->head );
        msg_free(mb);
		return;
	}
	if (ifp->if_ulPhyType == PHY_LOOP)
	{
        aos_dmem_free( (VOID*)mb->head );
        msg_free(mb);
		return;
	}

#if( CONFIG_BOARD_EIA == TRUE )
    srcip = if_get_out_ipaddr();
#else
    srcip = ifp->if_ulIpAddr;
#endif

	mbuf = (MBUF_S*)aos_dmem_alloc( MPE_LCM, SID_MBUF, MBUF_MBUF_SIZE );
    if( NULL == mbuf )
    {
        aos_dmem_free( (VOID*)mb->head );
        msg_free(mb);
        AOS_ASSERT(0);
        return;
    }

	mbuf->ulMbufMagic = MBUF_MAGIC_NUMBER;
    mbuf->stDataBlockDescriptor.ulDBMagic = DBES_MAGIC_NUMBER;
    mbuf->stDataBlockDescriptor.ulType = MBUF_TYPE_DATA;
    mbuf->stDataBlockDescriptor.ulOption = 0;
    mbuf->stDataBlockDescriptor.pstNextDataBlockDescriptor = NULL;

    mbuf->stDataBlockDescriptor.pucDataBlock = mb->head;
    mbuf->stDataBlockDescriptor.ulDataBlockLength = mb->truelen;
    mbuf->stDataBlockDescriptor.pucData = mb->data;
    mbuf->stDataBlockDescriptor.ulDataLength = mb->len;

    mbuf->ulTotalDataLength = mb->len;
    mbuf->ulDataBlockNumber = 1;
    mbuf->pstNextMBuf = NULL;
    (VOID)aos_memset( (VOID *) (& mbuf->stUserTagData), 0 , sizeof(MBUF_USERTAGDATA_S));
    len = mb->len;

    msg_free(mb);

    
	MBUF_PREPEND_MEMORY_SPACE(mbuf, sizeof(TCPIPHDR_S), (U32)MPE_LCM, ulResult);
	if (MBUF_OK != ulResult)
	{
		mbuf_destroy(mbuf);
		AOS_ASSERT(0);
	    return;
	}

	
	tcpip = MBUF_MTOD(mbuf, TCPIPHDR_S *);
    aos_memzero(&tcpip->pIHNext, 4);
    aos_memzero(&tcpip->pIHPrev, 4);
    tcpip->ucIHX1          	= 0;
    tcpip->ucIHProtocol     = IPPROTO_TCP;
    tcpip->sIHLen          	= AOS_HTONS((U16)(sizeof(TCPHDR_S) + len));
    seq = AOS_HTONL(seq);
    aos_memcpy((U8*)&tcpip->seqTHSeq, (U8*)&seq, 4);
    ack = AOS_HTONL(ack);
    aos_memcpy((U8*)&tcpip->seqTHAck, (U8*)&ack, 4);
    tcpip->ucTHX2          	= 0;
    tcpip->ucTHOffset     	= 5;
    tcpip->ucTHFlags       	= LCM_TCP_PUSH_ACK;
    tcpip->usTHWnd        	= AOS_HTONS(0x1000);
    tcpip->usTHCheckSum    	= 0;
    tcpip->usTHUrgentPoint 	= 0;

    tcpip->usTHSrcPort = AOS_HTONS(src_port);
	tcpip->usTHDstPort = addr->sin_usPort; 
    aos_memcpy(&tcpip->ihOverlaidIP.ih_stSrc.s_ulAddr, &srcip, 4);
    aos_memcpy(&tcpip->ihOverlaidIP.ih_stDst.s_ulAddr, &addr->sin_stAddr.s_ulAddr, 4);
	tcpip->usTHCheckSum = in_cksum(mbuf, (S32)( sizeof(TCPIPHDR_S)+ len));


    
	ip = MBUF_MTOD(mbuf, IP_S*);
	ip->ip_chHLen = 5;
    ip->ip_chVer  = 4;
    ip->ip_usLen  = AOS_HTONS( (U16)(sizeof(TCPIPHDR_S) + len) );
    ip->ip_chTTL  = 128;
    ip->ip_usId = AOS_HTONS(g_usIpId);
    ip->ip_usOff = 0;
    ip->ip_usOff |= AOS_HTONS(IP_DF);
    ip->ip_usSum  = 0;
    ip->ip_usSum = rtp_ip_cksum( (U8*)ip, sizeof(IP_S) );

    g_stIpStat.ips_ulLocalOut++;
	g_usIpId++;

	if (RT_FIELD_FLAGS(route.ro_pRt) & RTF_GATEWAY)
	{
		nexthop = RT_FIELD_GATEWAY(route.ro_pRt);
	}
	else
	{
        aos_memcpy(&nexthop, &(ip->ip_stDst.s_ulAddr), 4);
	}

	MBUF_ASSIGN_TAG_NETWORK_TYPE(mbuf, AF_INET);
	MBUF_ASSIGN_SEND_IFNET_INDEX(mbuf, route.ro_pRt->rt_ulIfIndex);
	MBUF_GET_TAG_NETWORK_IP_PTR(mbuf)->ulNextHopIpAddress = nexthop;
	if (ifp->if_pfLLCOutput(mbuf))
	{
	}
}


VOID lcm_tcp_rapid_send_to_eth( U16 src_port, U32 seq, U32 ack, struct msg_blk *mb, VOID *v_addr )
{
    SOCKADDRIN_S *addr = (SOCKADDRIN_S*)v_addr;
    MBUF_S       *mbuf;
    TCPIPHDR_S   *tcpip;
	IP_S         *ip;
    IFNET_S	     *ifp;
	ROUTE_S	      route;
	U32           len;
    U32           srcip, nexthop;
    U32           ulResult;

    if(NULL == mb)
    {
		return;
    }
    if(0 == addr->sin_stAddr.s_ulAddr
    || 0 == AOS_NTOHS(addr->sin_usPort)
    || U32_BUTT == addr->sin_stAddr.s_ulAddr
    || U16_BUTT == AOS_NTOHS(addr->sin_usPort))
    {
        aos_dmem_free( (VOID*)mb->head );
        msg_free(mb);
        return;
    }