lcm_rsock.c

abstract rtos

        {
            
            return AOS_SUCC;
        }
    }
    else
    {
        AOS_ASSERT( lclPort == g_pstRsock[s].lcl_port );

        if(  g_pstRsock[s].proto != rsock_proto
         ||  g_pstRsock[s].peer_port != srcPort
      	 ||  g_pstRsock[s].peer_ip != srcIp 
#if( CONFIG_BOARD_GMPU == TRUE )
	 	 || g_pstRsock[s].if_index != if_index
#endif
	)
        {
            if( g_ulRsockIpRefreshShowFlag )
            {
    			aos_printf( 0, "rsock ip refresh,RSOCK=%d,PROTO=%u,IP=%A,SPORT=%u,proto=%u,ip=%A,port=%u,payLen=%u",\
    				s, g_pstRsock[s].proto, g_pstRsock[s].peer_ip, g_pstRsock[s].peer_port, rsock_proto, srcIp, srcPort,payLen );

    	        if( RSOCK_PROTO_TCP == rsock_proto )
    	        {
    				debug_mem_show( 0, (U32)((U8*)tcp + tcp->ucOffset * 4) , 64 );
    	        }
    			else
    			{
    				debug_mem_show( 0, (U32)((U8*)udp+8), 64 );
    			}
            }
			return AOS_FAIL;
        }
    }

    rs = &g_pstRsock[s];
    if( RSOCK_PROTO_TCP == rsock_proto )
    {
        addr.sin_stAddr.s_ulAddr = srcIp;
        addr.sin_usPort = AOS_HTONS(srcPort);
        
        if( g_pstRsock[s].tcp_state < RSOCK_STATE_SYN_RECV
         ||  (S32)(tcpSeq + payLen - rs->tcp_ack) > 0 )
        {
            rs->tcp_ack = tcpSeq + payLen;
        }

        if( g_ulRsockDbgFlag && 0 == payLen )
        {
            aos_printf( MPE_RSOCK, "RSOCK(%u): port %u recv %s packet from %A %u ", 
                s, lclPort, rsock_get_tcp_signal(tcp->ucFlags), srcIp, srcPort );
        }

        
        if( LCM_TCP_SYN & tcp->ucFlags )
        {
            switch( g_pstRsock[s].tcp_state )
            {
                case RSOCK_STATE_INIT:
                    if( LCM_TCP_SYN == tcp->ucFlags )
                    {
                        if( !rs->seq_init )
                        {
                            rs->tcp_seq = lcm_get_tcp_iss();
                            rs->seq_init = 1;
                        }
                        rs->tcp_ack++;
                        rs->tcp_state = RSOCK_STATE_SYN_RECV;
                        
                        lcm_send_tcp_signal_by_if( if_index, LCM_TCP_SYN_ACK, lclPort, rs->tcp_seq, rs->tcp_ack, &addr );
                        if( g_ulRsockDbgFlag )
                        {
                            aos_printf( MPE_RSOCK, "RSOCK(%u): port %u send syn ack packet", s, lclPort );
                        }
                    }
                    break;

                case RSOCK_STATE_SYN_SEND:
                    if( LCM_TCP_ACK & tcp->ucFlags )
                    {
                        rs->tcp_seq++;
                        rs->tcp_ack++;
                        aos_timer_stop( &rs->tcp_tmr );
                        rs->connected = 1;
                        rs->tcp_state = RSOCK_STATE_ESTABLISHED;

                        if( 0 == rs->ref )
                        {
                            aos_timer_start( &rs->tcp_tmr, 
                                             MPE_RSOCK,
                                             RSOCK_WAIT_REF_TIMER_LEN, 
                                             RSOCK_WAIT_REF_TIMER,
                                             s,
                                             AOS_TIMER_NO_LOOP );
                        }

                        lcm_send_tcp_signal_by_if( if_index, LCM_TCP_ACK, lclPort, rs->tcp_seq, rs->tcp_ack, &addr );
                        if( g_ulRsockDbgFlag )                        
                        {
                            aos_printf( MPE_RSOCK, "RSOCK(%u): port %u send ack packet", s, lclPort );
                        }
                    }
                    break;
                    
                case RSOCK_STATE_SYN_RECV:
                    lcm_send_tcp_signal_by_if( if_index, LCM_TCP_SYN_ACK, lclPort, rs->tcp_seq, rs->tcp_ack, &addr );
                    if( g_ulRsockDbgFlag )
                    {
                        aos_printf( MPE_RSOCK, "RSOCK(%u): port %u send syn ack packet", s, lclPort );
                    }
                    break;
                    
                case RSOCK_STATE_ESTABLISHED:
                    if( LCM_TCP_SYN == tcp->ucFlags )
                    {
                        lcm_send_tcp_signal_by_if( if_index, LCM_TCP_SYN_ACK, lclPort, rs->tcp_seq, rs->tcp_ack, &addr );
                        if( g_ulRsockDbgFlag )
                        {
                            aos_printf( MPE_RSOCK, "RSOCK(%u): port %u send syn ack packet at estab state", s, lclPort );
                        }
                    }
                    break;

                default:
                    break;
            }
            
            rs->tcp_last_ack = rs->tcp_ack;
            return AOS_SUCC;
        }
        
        if( LCM_TCP_FIN & tcp->ucFlags )
        {
            rs->tcp_ack++;
            lcm_send_tcp_signal_by_if( if_index, LCM_TCP_ACK, lclPort, rs->tcp_seq, rs->tcp_ack, &addr );
            rs->tcp_last_ack = rs->tcp_ack;
            
            if( g_ulRsockDbgFlag )            
            {
                aos_printf( MPE_RSOCK, "RSOCK(%u): port %u send ack packet", s, lclPort );
            }
            if( 0 == rs->ref )
            {
                if( NULL != rs->tcp_tmr )
                {
                    aos_timer_stop( &rs->tcp_tmr );
                }
                rsock_free(rs);
            }
            else
            {
                
                if( NULL != rs->tcp_tmr )
                {
                    aos_timer_stop( &rs->tcp_tmr );
                }
	            rs->seq_init  = 0;
                rs->connected = 0;
	            rs->tcp_state = RSOCK_STATE_INIT;
            }
            return AOS_SUCC;
        }

        if( LCM_TCP_ACK & tcp->ucFlags )
        {
            if( RSOCK_STATE_SYN_RECV == rs->tcp_state )
            {
                if( (S32)(tcpAck - rs->tcp_seq) > 0 )
                {
                    rs->tcp_seq = tcpAck;
                }
                
                rs->connected = 1;
                rs->tcp_state = RSOCK_STATE_ESTABLISHED;

                if( rs->ref )
                {
                    aos_timer_stop( &rs->tcp_tmr );
                }
                else
                {
                    aos_timer_start( &rs->tcp_tmr, 
                                     MPE_RSOCK,
                                     RSOCK_WAIT_REF_TIMER_LEN, 
                                     RSOCK_WAIT_REF_TIMER,
                                     s,
                                     AOS_TIMER_NO_LOOP );
                }
            }
        }

        if( RSOCK_STATE_ESTABLISHED == rs->tcp_state )
        {
            if( (S32)(rs->tcp_ack - rs->tcp_last_ack) >= 1024 )
            {
                lcm_send_tcp_signal_by_if( if_index, LCM_TCP_ACK, lclPort, rs->tcp_seq, rs->tcp_ack, &addr );
                rs->tcp_last_ack = rs->tcp_ack;
            }
        }        
    }

    return AOS_SUCC;
}


U8  *rsock_payload_addr( MBUF_S *m )
{
    IP_S     *ip;
    TCPHDR_S *tcp;
        
	ip = MBUF_MTOD(m, IP_S*);
    if( IPPROTO_TCP == ip->ip_chPr )
    {
        tcp = (TCPHDR_S*)((U8*)ip + (ip->ip_chHLen << 2));
        return (U8*)tcp + (tcp->ucOffset << 2);
    }
    else
    {
        return (U8*)ip + (ip->ip_chHLen << 2) + 8;
    }
}

U32 rsock_logic2app(U8 *buf, U32 len, U16 usDstPort, U16 usConnPort)
{

#if( AOS_INCLUDE_SERVICE_RTPRTCP == TRUE )
#if( CONFIG_BOARD_GMPU == TRUE )
    U16 usReflectConPort;

    if( rtp_is_rtp_port( usDstPort ) )
    {
        if( AOS_SUCC == rtp_mux_get_p2p_reflect_port( usDstPort, usConnPort, &usReflectConPort) )
        {
            p2p_trans_send_logic( usReflectConPort, buf, len );
        }
        else
        {
            rtp_mux_p2p_rapid_fwd( buf, len, usDstPort, if_get_out_ipaddr(), usConnPort );
        }
        return AOS_SUCC;
    }
    else
#endif        
#else
#endif
    {
        lcm_p2p_rapid_fwd( buf, len, usDstPort, if_get_out_ipaddr(), usConnPort );
    }

    return AOS_SUCC;
}

U32 rsock_fwd2app(U8 *buf, U32 len, U16 usDstPort, U32 ulSrcIp, U16 usSrcPort)
{
#if( AOS_INCLUDE_SERVICE_RTPRTCP == TRUE )
    if( rtp_is_rtp_port( usDstPort ) )
#if( CONFIG_BOARD_EIA == TRUE )
    {
        MBUF_S    *mbuf;
    	IP_S	  *ip;
    	UDPHDR_S  *udp;
        U32       ulResult, dstip;
        
        MBUF_CREATE_BY_DATA_BLOCK(mbuf, mem_obj_head(buf), mem_obj_size(buf), buf, len, usDstPort, MPE_RSOCK);
        if (NULL == mbuf)
        {
            AOS_ASSERT(0);
            aos_dmem_free( mem_obj_head(buf) );
            return AOS_SUCC;
        }

        MBUF_PREPEND_MEMORY_SPACE( mbuf, sizeof(UDPHDR_S)+sizeof(IP_S), MPE_RSOCK, ulResult );
        if( MBUF_OK != ulResult )
        {
            AOS_ASSERT(0);
            aos_dmem_free( mem_obj_head(buf) );
            return AOS_SUCC;
        }

        ip  = MBUF_MTOD(mbuf, IP_S*);
    	udp = (UDPHDR_S *)(ip+1);
        udp->uh_sULen = AOS_HTONS( 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( len+sizeof(UDPHDR_S)+ sizeof(IP_S) );
        ip->ip_usId   = 0;
        ip->ip_usOff = 0;
        ip->ip_chTTL  = 64;
        ip->ip_chPr = 0x11; 
        ip->ip_usSum = 0;

        aos_memcpy((U8*)&(ip->ip_stSrc.s_ulAddr),(U8*)&ulSrcIp,4);
        dstip= if_get_out_ipaddr();
        aos_memcpy((U8*)&(ip->ip_stDst.s_ulAddr), (U8*)&dstip ,4);
        ip->ip_usSum = rtp_ip_cksum( (U8*)ip, sizeof(IP_S) );

        rtp_eia_input(mbuf);
        return AOS_SUCC;
    }
#else
    {
        rtp_mux_p2p_rapid_fwd( buf, len, usDstPort, ulSrcIp, usSrcPort );
        return AOS_SUCC;
    }
#endif
    else
#endif
    {
        lcm_p2p_rapid_fwd( buf, len, usDstPort, ulSrcIp, usSrcPort );
    }
    return AOS_SUCC;
}
U32 rsock_get_out_ip( RSOCK s )
{
#if( CONFIG_BOARD_GMPU == TRUE )
    IFNET_S	     *ifp;
#endif

    if( s < 0 || s >= MAX_RSOCK_NUM || !g_pstRsock[s].init )
    {
        return 0;
    }

#if( CONFIG_BOARD_GMPU == TRUE )
    if( g_pstRsock[s].if_index )
    {
    	ifp = if_get_if_by_index(g_pstRsock[s].if_index);
        if( NULL != ifp )
        {
            return ifp->if_ulIpAddr;
        }
    }
#endif

    return if_get_out_ip_by_dstip( g_pstRsock[s].peer_ip );
}

BOOL_T rsock_is_reservport(U16 usPort)
{
#if( CONFIG_BOARD_EIA == TRUE )
    if( usPort >= g_usRsockBasePort && usPort < (g_usRsockBasePort+RSOCK_FREE_PORT_NUM) )
    {
        return TRUE;
    }
#endif

    return FALSE;
}

U16 rsock_alloc_tcp_port()
{
    U32 i, j, pos;
    U16 usPort;

    struct aos_list *node;
    lcm_port_t      *pPort;

    for( i = 0; i < RSOCK_TCP_PORT_ARY_NUM; i++ )
    {
        pos = (g_ulTcpPortAllocPos + i)&RSOCK_TCP_PORT_ARY_MASK;
        if( U32_BUTT != g_pTcpPortAllocFlag[pos] )
        {
            for( j = 0; j < 32; j++ )
            {
                if( !(g_pTcpPortAllocFlag[pos] & ( 1L << j )) )
                {
                    g_pTcpPortAllocFlag[pos] |= (1L<<j);

                    usPort = (U16)(g_usRsockBasePort + (pos << 5 ) + j);

                    if( FALSE == lcm_is_port_reserved_for_app(usPort) )
                    {
                        if( g_ulRsockDbgFlag )
                        {
                            aos_printf( MPE_RSOCK, "Alloc Tcp Port,port=%u", usPort );
                        }
                        g_ulTcpPortAllocPos = pos;
                        return usPort;
                    }
                }
            }
        }
    }

    
    node = aos_list_fetch(&g_stLcmPortWaitFreeList);
    if( NULL != node )
    {
        AOS_ASSERT(0);
        pPort = aos_list_entry( node, lcm_port_t, node );
        g_ulLcmPortWaitFreeCnt--;

        usPort = pPort->usPort;

        aos_dmem_free(pPort);
        
        return usPort;
    }

    return U16_BUTT;
}

U16 rsock_alloc_udp_port()
{
    U32 i, j, pos;
    U16 usPort;

    for( i = 0; i < RSOCK_UDP_PORT_ARY_NUM; i++ )
    {
        pos = (g_ulUdpPortAllocPosX + i)&RSOCK_UDP_PORT_ARY_MASK;
        
        if( U32_BUTT != g_UdpPortAllocFlag[pos] )
        {
            for( j = ((i) ? 0 : g_ulUdpPortAllocPosY); j < 32; j++ )
            {
                if( !(g_UdpPortAllocFlag[pos] & ( 1L << j )) )
                {
                    g_UdpPortAllocFlag[pos] |= (1L<<j);
                    
                    usPort = (U16)(g_usRsockBasePort + (pos<< 5 ) + j);
                    if( FALSE == lcm_is_port_reserved_for_app(usPort) )
                    {
                        if( g_ulRsockDbgFlag )
                        {
                            aos_printf( MPE_RSOCK, "Alloc Udp Port,port=%u", usPort );
                        }
                        g_ulUdpPortAllocPosX = pos;
                        g_ulUdpPortAllocPosY = j;
                        g_ulUdpPortAllocPosY++;
                        if( 32 == g_ulUdpPortAllocPosY )
                        {
                            g_ulUdpPortAllocPosY = 0;
                            g_ulUdpPortAllocPosX++;
                            g_ulUdpPortAllocPosX &= RSOCK_UDP_PORT_ARY_MASK;
                        }
                        return usPort;
                    }
                }
            }
        }
    }

    return U16_BUTT;    
}

VOID rsock_free_tcp_port( U16 usPort )
{
    lcm_port_t *pPort;
    U32        i, j;
    

    pPort = aos_dmem_alloc( MPE_RSOCK, 102, sizeof(lcm_port_t) );
    if( NULL == pPort )
    {
        
        i = (usPort - g_usRsockBasePort) >> 5;
        j = (usPort - g_usRsockBasePort) & 31;

        g_pTcpPortAllocFlag[i] &= ~(1L<<j);

        if( g_ulRsockDbgFlag )
        {
            aos_printf( MPE_RSOCK, "malloc fail, Free Tcp Port,port=%u", pPort->usPort );
        }

        return;
    }
    pPort->usPort = usPort;
    pPort->expire = RSOCK_TCP_PORT_FREE_TIME;
    aos_list_add_tail( &g_stLcmPortWaitFreeList, &pPort->node );
    g_ulLcmPortWaitFreeCnt++;

    if( g_ulRsockDbgFlag )
    {
        aos_printf( MPE_RSOCK, "Add to Wait Free List, Tcp port=%u", usPort );
    }
}

VOID rsock_free_udp_port( U16 usPort )
{
    U32        i, j;
    
    i = (usPort - g_usRsockBasePort) >> 5;
    j = (usPort - g_usRsockBasePort) & 31;

    if( i >= RSOCK_UDP_PORT_ARY_NUM )
    {
        return;
    }

    g_UdpPortAllocFlag[i] &= ~(1L<<j);

    if( g_ulRsockDbgFlag )
    {
        aos_printf( MPE_RSOCK, "Free Udp Port,port=%u", usPort );
    }
}

VOID rsock_port_expire()
{
    lcm_port_t *pPort;
    struct aos_list *node, *next;
    U32 i, j;

    for( node = g_stLcmPortWaitFreeList.next; node != &g_stLcmPortWaitFreeList; node = next )
    {
        next = node->next;
        pPort = aos_list_entry(node, lcm_port_t, node);
        if( pPort->expire > 5 )
        {
            pPort->expire -= 5;
        }
        else
        {
            i = (pPort->usPort - g_usRsockBasePort) >> 5;
            j = (pPort->usPort - g_usRsockBasePort) & 31;
            g_pTcpPortAllocFlag[i] &= ~(1L<<j);

            aos_list_delete(node);
            if( g_ulRsockDbgFlag )
            {
                aos_printf( MPE_RSOCK, "Free Tcp Port,port=%u", pPort->usPort );
            }

            aos_dmem_free(pPort);
            g_ulLcmPortWaitFreeCnt--;
        }
    }
        
}
U32 rsock_is_rapid_pkt( MBUF_S* pMBuf )
{
    IP_S            *ip;
    UDPHDR_S        *udp; 
    TCPHDR_S        *tcp;
	U16				dst_port;
    U32             dstip;

	ip = MBUF_MTOD(pMBuf, IP_S*);

    aos_memcpy((U8*) &dstip, (U8*)&(ip->ip_stDst.s_ulAddr),4);

    if( dstip != if_get_out_ip_by_ifindex( MBUF_GET_RECEIVE_IFNET_INDEX(pMBuf) ) )