lcm_drv.c

abstract rtos

#if (AOS_INCLUDE_DEV_CLIENT == TRUE)
	if(ht_istunnelmode())
	{
	    ht_send_msg_rapid(mb, src_port, AOS_NTOHS(addr->sin_usPort));
	    return;
    }
#elif(AOS_INCLUDE_DEV_SERVER == TRUE)
	if((addr->sin_stAddr.s_ulAddr == AOS_HTONL(0x7F000001)
	|| addr->sin_stAddr.s_ulAddr == if_get_out_ipaddr())
	&& ht_istunneludp(AOS_NTOHS(addr->sin_usPort)))
	{
		ht_send_msg_rapid(mb, src_port
						, AOS_NTOHS(addr->sin_usPort));

		return;
	}
#endif

    lcm_tcp_rapid_send_to_eth_no_warpper(src_port, seq, ack, mb, v_addr);
}

U8 g_ucLcmTcpSynOpt[] = {0x02, 0x04, 0x05, 0x28, 0x01, 0x01, 0x04, 0x02};

U8 g_ucLcmTcpSynAckOpt[] = {0x02, 0x04, 0x05, 0x28 };

extern U32 g_ulRsGateWay[];

VOID lcm_send_tcp_signal_by_if( U32 if_index, U32 flag, U16 src_port, U32 seq, U32 ack, 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           srcip, nexthop = 0;
    U32           tcpOptLen;
    U8            *tcpOpt;

    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))
    {
        return;
    }

#if(CONFIG_BOARD_GMPU == TRUE)
	if((addr->sin_stAddr.s_ulAddr == AOS_HTONL(0x7F000001)
	|| addr->sin_stAddr.s_ulAddr == if_get_out_ipaddr()))
	{
		return;
	}
#endif

    if( LCM_TCP_SYN == flag )
    {
        tcpOpt    = g_ucLcmTcpSynOpt;
        tcpOptLen = sizeof(g_ucLcmTcpSynOpt);
    }
    else if( LCM_TCP_SYN_ACK == flag )
    {
        tcpOpt    = g_ucLcmTcpSynAckOpt;
        tcpOptLen = sizeof(g_ucLcmTcpSynAckOpt);
    }
    else
    {
        tcpOpt    = NULL;
        tcpOptLen = 0;
    }
#if( CONFIG_BOARD_GMPU == TRUE )
    if( ( g_ulRsGateWay[0] || g_ulRsGateWay[1] ) && if_index )
    {
    	ifp = if_get_if_by_index(if_index);
    	if (NULL == ifp || NULL == ifp->if_pfOutput)
    	{
    		AOS_ASSERT(0);
            return;
    	}
    	if (ifp->if_ulPhyType == PHY_LOOP)
    	{
    		AOS_ASSERT(0);
            return;
    	}
        if( ( addr->sin_stAddr.s_ulAddr & ifp->if_ulIpMask )
         == ( ifp->if_ulIpAddr & ifp->if_ulIpMask ) )
        {
            
            nexthop = addr->sin_stAddr.s_ulAddr;
        }
        else
        {
            if( ifp->if_ulPortNum <= SERVICE_ETHNET_PORT )
            {
                nexthop = g_ulRsGateWay[ifp->if_ulPortNum];
            }
        }
    }
    
    if( !nexthop )
#endif
    {
    	((SOCKADDRIN_S *)&(route.ro_stDst))->sin_stAddr.s_ulAddr = addr->sin_stAddr.s_ulAddr;
        rt_alloc(&route);
        if (NULL == route.ro_pRt)
        {
    		aos_printf( MPE_LCM, "LCM DRV: No Route to %A", addr->sin_stAddr.s_ulAddr );
            return;
        }
    	ifp = if_get_if_by_index(route.ro_pRt->rt_ulIfIndex);
    	if (NULL == ifp || NULL == ifp->if_pfOutput)
    	{
    		AOS_ASSERT(0);
            return;
    	}

    	if (ifp->if_ulPhyType == PHY_LOOP)
    	{
    		AOS_ASSERT(0);
            return;
    	}

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

	if (NULL == (mbuf = mbuf_create(34, sizeof(TCPIPHDR_S)+tcpOptLen, MBUF_TYPE_DATA, MPE_LCM)))
	{
		AOS_ASSERT(0);
		return ;
	}
#if( CONFIG_BOARD_EIA == TRUE )
    srcip = if_get_out_ipaddr();
#else
    srcip = ifp->if_ulIpAddr;
#endif

	
	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          	= (S16)AOS_HTONS((U16)(sizeof(TCPHDR_S)+tcpOptLen));
    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;
    if( tcpOptLen )
    {
        tcpip->ucTHOffset   += tcpOptLen/4;
    }
    tcpip->ucTHFlags       	= (U8)flag;
    tcpip->usTHWnd        	= (( LCM_TCP_RESET & flag ) ? 0 : 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);

    
    if( tcpOptLen )
    {
        aos_memcpy( (U8*)(tcpip+1), tcpOpt, tcpOptLen );
    }
	tcpip->usTHCheckSum = in_cksum( mbuf, (S32)(sizeof(TCPIPHDR_S)+ tcpOptLen) );


    
	ip = MBUF_MTOD(mbuf, IP_S*);
	ip->ip_chHLen = 5;
    ip->ip_chVer  = 4;
    ip->ip_usLen  = AOS_HTONS( (U16)(sizeof(TCPIPHDR_S) + tcpOptLen) );
    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++;

	MBUF_ASSIGN_TAG_NETWORK_TYPE(mbuf, AF_INET);
	MBUF_ASSIGN_SEND_IFNET_INDEX(mbuf, ifp->if_ulIfIndex);
	MBUF_GET_TAG_NETWORK_IP_PTR(mbuf)->ulNextHopIpAddress = nexthop;
	if (ifp->if_pfLLCOutput(mbuf))
	{
	}
}



VOID lcm_send_tcp_signal_to_eth( U32 flag, U16 src_port, U32 seq, U32 ack, VOID *v_addr )
{
    lcm_send_tcp_signal_by_if( 0, flag, src_port, seq, ack, v_addr );
}

#ifndef TCP_ISSINCR
#define TCP_ISSINCR   128000
#endif

extern TCP_SEQ  g_stSeqTCPISS;              	
U32 lcm_get_tcp_iss()
{
    U32 seq = g_stSeqTCPISS;

    g_stSeqTCPISS += TCP_ISSINCR / 2;

    return seq;

}



VOID lcm_p2p_rapid_fwd(U8 *buf, U32 len, U16 usDstPort, U32 ulSrcIp, U16 usSrcPort)
{
    MPE             dstMpe;
    MBUF_S          *pstMbuf;
    U32              ulResult, ulDstIp, lockKey;
    IP_S            *ip;
    UDPHDR_S        *udp;

    if( FALSE == m_ulMsgEnable )
    {
        aos_dmem_free(mem_obj_head(buf));
        return;
    }

    dstMpe = lcm_get_mpe_by_port(usDstPort);
    if( U32_BUTT == dstMpe )
    {
        aos_dmem_free(mem_obj_head(buf));
        return;
    }
    
    MBUF_CREATE_BY_DATA_BLOCK( pstMbuf, mem_obj_head(buf), mem_obj_size(buf), buf, len, dstMpe, MPE_LCM );
    if( NULL == pstMbuf )
    {
        aos_dmem_free(mem_obj_head(buf));
        return;
    }

    MBUF_PREPEND_MEMORY_SPACE( pstMbuf, sizeof(IP_S)+sizeof(UDPHDR_S), MPE_LCM, ulResult );
    if( MBUF_OK != ulResult )
    {
        mbuf_destroy( pstMbuf );
        return;
    }

    ip  = MBUF_MTOD(pstMbuf, IP_S*);
    udp = (UDPHDR_S*)(ip+1);

    udp->uh_sULen  = AOS_HTONS((U16)( len+sizeof(UDPHDR_S)));
    udp->uh_usSPort = AOS_HTONS(usSrcPort);
    udp->uh_usDPort = AOS_HTONS(usDstPort);
    udp->uh_usSum  = 0;

    ip->ip_chHLen = 5;
    ip->ip_chVer  = 4;
    ip->ip_chTOS  = 0;		
    ip->ip_usLen  = AOS_HTONS((U16)(len+sizeof(UDPHDR_S)+sizeof(IP_S)));
    ip->ip_usId   = 0;
    ip->ip_sOff  = 0;
    ip->ip_chTTL  = 64;
    ip->ip_chPr   = 0x11; 
    ip->ip_usSum  = 0;

    ulDstIp = if_get_out_ipaddr();
    aos_memcpy(&ip->ip_stSrc.s_ulAddr, &ulSrcIp, 4);
    aos_memcpy(&ip->ip_stDst.s_ulAddr, &ulDstIp, 4);

    lockKey = aos_int_lock();
  	if(!MBUF_QUE_IS_FULL(&lcm_rapid_pkt_list))
  	{
        MBUF_QUE_ENQUEUE( &lcm_rapid_pkt_list,pstMbuf );
  	}
    else
    {
        mbuf_destroy(pstMbuf);
    }
    aos_int_unlock(lockKey);
}


#ifdef CONFIG_SIMULATE_E1

#include "ip/ip_pub.h"
#include "socket/sock_pub.h"
#include "socket/sock_err.h"
#include "db_pub.h"

LCM_PHY_RCV hdlc_rcv=0;
struct msg_blk_que hdlc_tx_que = {0,};
U32 lcm_sim_hdlc_tx_task_id    = U32_BUTT;
U32 lcm_sim_hdlc_rcv_task_id    = U32_BUTT;

extern BOOL_T      v5_get_phyc_v5no_by_commport( U16 usCommPort, U8 *pucPhyC, U8 *ucV5No );
extern BOOL_T v5_get_commport_by_phyc( U8 ucPhyC, U16 *usCommPort );

VOID lcm_sim_tx_task( );
VOID lcm_sim_hdlc_recv_task( );
U32 lcm_sim_hdlc_send_over_udp( U32 port, struct msg_blk *mb );

U32 lcm_hdlc_sim_init()
{
    U32 result;
    msg_que_init(&hdlc_tx_que);

    result = aos_task_create((U8 *)"h_rcv", 10*1024, TASK_PRIO_NORMAL, AOS_TASK_NOPREEMPT,
                 (VOID(*)(VOID *))lcm_sim_hdlc_recv_task, (VOID*)0, &lcm_sim_hdlc_rcv_task_id);
    if( AOS_SUCC != result )
    {
        return result;
    }

    result = aos_task_create((U8 *)"h_tx", 10*1024, TASK_PRIO_NORMAL, AOS_TASK_NOPREEMPT,
                 (VOID(*)(VOID *))lcm_sim_tx_task, (VOID*)0, &lcm_sim_hdlc_tx_task_id);
    if( AOS_SUCC != result )
    {
        return result;
    }

    result= lcm_add_drv( LCM_DRV_HDLC,
                         N201, (LCM_PHY_SND)lcm_sim_hdlc_send_over_udp, &hdlc_rcv );


    return result;

}

U32 lcm_sim_hdlc_send_over_udp( U32 port, struct msg_blk *mb )
{
    U32 v5_id;
    U8 phy_c, v5_no, link_id, ts_no;


    if( NULL == mb || NULL == mb->data )
    {
        if( NULL != mb )
        {
            msg_free( mb );
        }

        return AOS_FAIL;
    }

    if( FALSE == v5_get_phyc_v5no_by_commport( (U16)port, &phy_c, &v5_no ) )
    {
        goto sim_send_fail;
    }

    if( FALSE == db_get_linkid_tsno_by_phyc_index(phy_c, &link_id, &ts_no) )
    {
        goto sim_send_fail;
    }

    if( FALSE == db_get_v5id_by_v5no(v5_no, &v5_id) )
    {
        goto sim_send_fail;
    }

    
    *(U32*)msg_push( mb, sizeof(U32) ) = AOS_HTONL(v5_id);
    *(U8*)msg_push( mb, sizeof(U8) )   = link_id;
    *(U8*)msg_push( mb, sizeof(U8) )   = ts_no;

    if( U32_BUTT != lcm_sim_hdlc_tx_task_id )
    {
        msg_que_tail( &hdlc_tx_que, mb );
        aos_event_post( lcm_sim_hdlc_tx_task_id, MSG_SYNC_EVENT );
        return 0;
    }

sim_send_fail:
    aos_dmem_free( (VOID*)mb->head );
    msg_free( mb );

	return AOS_FAIL;
}

VOID lcm_sim_hdlc_recv_task( )
{
    S32 iFd,iRet;
    SOCKADDRIN_S  addr;
    S32 Len = sizeof(addr);

    struct msg_blk *mb;

    if( NULL == hdlc_rcv )
    {
        return;
    }

#ifndef CONFIG_SIM_HDLC_PEER_IP
#error pls define CONFIG_SIM_HDLC_PEER_IP
#endif

    aos_memset(&addr,0,(U32)Len);
    addr.sin_chFamily = AF_INET;
    addr.sin_usPort   = AOS_HTONS(CONFIG_SIM_HDLC_UDP_PORT);
    addr.sin_stAddr.s_ulAddr = 0;

    iFd = socket(AF_INET, SOCK_DGRAM,IPPROTO_UDP);
    if( iFd < 0 )
    {
        aos_printf( MPE_EDRV, "Hdlc:create edrv recv sock fail" );
        return;
    }
    
    iRet = bind(iFd,(SOCKADDRIN_S *)&addr,sizeof(SOCKADDRIN_S));
    if( iRet < 0 )
    {
        aos_printf( MPE_EDRV, "Hdlc:bind hdlc recv sock fail" );
        return;
    }

    mb = msg_alloc4drv( N201 );
    if( NULL == mb )
    {
        return;
    }

    for(;;)
    {
        struct msg_blk *newmb;
        U32 v5_id;
        U8  link_id, ts_no, v5_no, phy_c;
        U16 commport;

        iRet = recvfrom(iFd, (S8*)mb->data, mb->end-mb->data, 0,  (SOCKADDRIN_S *)&addr , (S32*)&Len);
        if( iRet <= 0)
        {
            aos_task_delay(1);
            continue;
        }

        newmb = msg_alloc4drv( N201 );
        if( NULL == newmb )
        {
            
            
            continue;
        }

        mb->len = (U32)iRet;
        mb->tail = mb->data + mb->len;
        
        ts_no = *(U8*)mb->data;
        msg_pull( mb, sizeof(U8) );

        link_id = (U8)AOS_NTOHL( *(U32*)mb->data );
        msg_pull( mb, sizeof(U8) );

        v5_id = AOS_NTOHL(*(U32*)mb->data);
        msg_pull( mb, sizeof(U32) );

        if( FALSE == db_get_v5no_by_v5id( v5_id, &v5_no) )
        {
            mb = newmb;
            continue;
        }

        if( FALSE == db_get_phyc_by_v5no_linkid_tsno(v5_no, link_id, ts_no, &phy_c) )
        {
            mb = newmb;
            continue;
        }

        if( FALSE == v5_get_commport_by_phyc( phy_c, &commport) )
        {
            mb = newmb;
            continue;
        }

        (*hdlc_rcv)( LCM_DRV_HDLC, commport, mb );

        mb = newmb;

    }

}

VOID lcm_sim_tx_task( )
{
    S32 iRet, iFd;
    SOCKADDRIN_S  dst_addr,addr;
    S32 Len = sizeof(SOCKADDRIN_S);
    U32 event;

    struct msg_blk *mb;

    aos_memset(&addr,0,(U32)Len);
    addr.sin_chFamily = AF_INET;
    addr.sin_usPort   = AOS_HTONS(CONFIG_SIM_HDLC_UDP_PORT);
    addr.sin_stAddr.s_ulAddr = 0;

    iFd = socket(AF_INET, SOCK_DGRAM,IPPROTO_UDP);
    if( iFd < 0 )
    {
        aos_printf( MPE_EDRV, "Hdlc:create edrv recv sock fail" );
        return;
    }
    
#if 0
    if( bind(iFd,&addr,Len) )
    {
        aos_printf( MPE_EDRV, "Hdlc:bind edrv recv sock fail" );
        return;
    }
#endif

    aos_memset(&dst_addr,0,(U32)Len);
    dst_addr.sin_chFamily = AF_INET;
    dst_addr.sin_usPort   = AOS_HTONS(CONFIG_SIM_HDLC_UDP_PORT);
    aos_strtoipaddr(CONFIG_SIM_HDLC_PEER_IP, &dst_addr.sin_stAddr.s_ulAddr);

    dst_addr.sin_stAddr.s_ulAddr = AOS_HTONL(dst_addr.sin_stAddr.s_ulAddr);

    aos_printf( MPE_EDRV, "Hdlc:start to send message" );
    for(;;)
    {
        aos_event_wait( MSG_SYNC_EVENT, AOS_WAIT_ANY, 0, &event );
        while( NULL != (mb=msg_deque( &hdlc_tx_que )) )
        {
            

            iRet = sendto(iFd, (S8*)mb->data, (S32)mb->len, 0, &dst_addr, (S32)Len);
            if( iRet <= 0)
            {
                #ifdef LCM_DEBUG
                {
                    S8  str[20];
                    aos_ipaddrtostr( AOS_NTOHL(dst_addr.sin_stAddr.s_ulAddr), str );
                    aos_printf( MPE_EDRV,"Hdlc:Send data fail,ip=%s,port=%d",
                                str, AOS_NTOHS(dst_addr.sin_usPort) );
                }
                #endif
            }
            aos_dmem_free( (VOID*)mb->head );
            msg_free( mb );
        }
    }
}
#endif

#ifdef __cplusplus
}
#endif