lcm_rsock.c

abstract rtos

        rs->peer_port = port;
        rs->lcl_port  = lcl_port;
        rs->tcp_seq   = 0;
        rs->tcp_ack   = 0;
        rs->tcp_tmr   = NULL;
        rs->tcp_last_ack = 0;
#if( CONFIG_BOARD_GMPU == TRUE )
        rs->if_index  = if_index;
#endif        
        aos_list_add_tail( list, node );

		if( g_ulRsockDbgIpFilter == ip )
		{
			aos_printf( 0, "rsock init:SOCK=%d,REF=%u,ip=%A,port=%u,lclport=%u,allocflag=%u,proto=%u",
				(rs - g_pstRsock),rs->ref,ip, port,lcl_port,alloc_lclport_flag,proto );
		}

        return rs - g_pstRsock;
    }
    else
    {
        AOS_ASSERT(0);

        if( allocated )
        {
            if( RSOCK_PROTO_UDP == proto )
            {
                rsock_free_udp_port( new_port );
            }
            else
            {
                rsock_free_tcp_port( new_port );
            }
        }
     }

    return NULL_RSOCK;
}

RSOCK rsock_find( U32 proto, U32 ip, U16 port, U16 lcl_port, U32 if_index)
{
    U32             k;
    struct aos_list *list, *node;
    rsock_t         *rs;
    
    k = RSOCK_HASHFUNC( port, ip );
    if( RSOCK_PROTO_UDP == proto )
    {
        list = &g_RsockHashList4Udp[k];
    }
    else if( RSOCK_PROTO_TCP == proto )
    {
        list = &g_RsockHashList4Tcp[k];
    }
    else
    {
        return NULL_RSOCK;
    }
    for( node = list->next; node != list; node = node->next )
    {
        rs =  aos_list_entry( node, rsock_t, rsock_next );
        if( rs->peer_ip == ip 
         && rs->peer_port == port
         && rs->lcl_port == lcl_port 
#if( CONFIG_BOARD_GMPU == TRUE )
		 && rs->if_index == if_index
#endif         
         )
        {
            return rs - g_pstRsock;
        }        
    }

    return NULL_RSOCK;
}

VOID rsock_free( rsock_t *rs )
{
    aos_list_delete( &rs->rsock_next );
    aos_list_add_tail( &g_FreeRsockList, &rs->rsock_next );

    if( NULL != rs->tcp_tmr )
    {
        AOS_ASSERT(0);
        aos_timer_stop( &rs->tcp_tmr );
    }

    if( rs->alloc_flag )
    {
        if( RSOCK_PROTO_UDP == rs->proto )
        {
            rsock_free_udp_port( rs->lcl_port );
        }
        else
        {
            rsock_free_tcp_port( rs->lcl_port );
        }
        rs->alloc_flag = 0;
    }

    rs->init = 0;
}

U32 rsock_connect( RSOCK s )
{
    SOCKADDRIN_S addr;
    
    if( s < 0 || s >= MAX_RSOCK_NUM || !g_pstRsock[s].init )
    {
        return RSOCK_ERR;
    }

    if( g_pstRsock[s].connected )
    {
        return AOS_SUCC;
    }

    if( RSOCK_PROTO_UDP == g_pstRsock[s].proto )
    {
        g_pstRsock[s].connected = 1;
        return AOS_SUCC;
    }

    
    if( !g_pstRsock[s].seq_init )
    {
        g_pstRsock[s].tcp_seq = lcm_get_tcp_iss();
        g_pstRsock[s].seq_init = 1;
        g_pstRsock[s].tcp_state = RSOCK_STATE_SYN_SEND;
        
        aos_timer_start( &g_pstRsock[s].tcp_tmr, 
                         MPE_RSOCK,
                         RSOCK_SYN_SEND_TIMER_LEN, 
                         RSOCK_SYN_SEND_TIMER,
                         s,
                         AOS_TIMER_NO_LOOP );

        addr.sin_stAddr.s_ulAddr = g_pstRsock[s].peer_ip;
        addr.sin_usPort          = AOS_HTONS(g_pstRsock[s].peer_port);

		#if( CONFIG_BOARD_GMPU == TRUE )
	        lcm_send_tcp_signal_by_if( g_pstRsock[s].if_index, LCM_TCP_SYN, g_pstRsock[s].lcl_port, g_pstRsock[s].tcp_seq, 
	                       g_pstRsock[s].tcp_ack, &addr );
		#else
			lcm_send_tcp_signal_to_eth( LCM_TCP_SYN, g_pstRsock[s].lcl_port, g_pstRsock[s].tcp_seq, 
	                       g_pstRsock[s].tcp_ack, &addr );	
		#endif
        if( g_ulRsockDbgFlag )
        {
            aos_printf( MPE_RSOCK, "RSOCK(%u): send syn to %A %u", s, g_pstRsock[s].peer_ip, g_pstRsock[s].peer_port );
        }
    }

    return RSOCK_AGAIN;
}

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

U32 rsock_close( RSOCK s )
{
    SOCKADDRIN_S addr;
#if( TXRX_INTERUPPT_ENABLE == TRUE )
	MSG_S msg;
	U32   *pRSock;

	if( intCount() )
	{
		pRSock = aos_msg_alloc( MPE_RSOCK, 4 );
		if( pRSock )
		{
			msg.srcProcessorId = LOCAL_PROCESSOR_ID;
			msg.srcMpe         = MPE_RSOCK;
			msg.dstProcessorId = LOCAL_PROCESSOR_ID;
			msg.dstMpe         = MPE_RSOCK;
			msg.msgPrio        = MSG_PRIO_NORMAL;
			msg.ulSize         = 4;
			msg.pvMsgBuf       = (VOID*)pRSock;

			*pRSock = s;

			aos_msg_send( &msg );
			
			return AOS_SUCC;
		}
	}
#endif
    if( s < 0 || s >= MAX_RSOCK_NUM || !g_pstRsock[s].init || !g_pstRsock[s].ref )
    {
        return RSOCK_ERR;
    }

	if( g_ulRsockDbgIpFilter == g_pstRsock[s].peer_ip )
	{
		aos_printf( 0, "rsock close: sock=%d,ip=%A,port=%u,lclport=%u,ref=%u",
			s,g_pstRsock[s].peer_ip,g_pstRsock[s].peer_port,g_pstRsock[s].lcl_port,
			g_pstRsock[s].ref );
	}


    g_pstRsock[s].ref--;
    if( g_pstRsock[s].ref )
    {
        return AOS_SUCC;
    }

    
    if( RSOCK_PROTO_TCP == g_pstRsock[s].proto 
     && !g_pstRsock[s].is_tcp_server)
    {
        addr.sin_stAddr.s_ulAddr = g_pstRsock[s].peer_ip;
        addr.sin_usPort          = AOS_HTONS(g_pstRsock[s].peer_port);

		#if( CONFIG_BOARD_GMPU == TRUE )
	        lcm_send_tcp_signal_by_if( g_pstRsock[s].if_index, LCM_TCP_FIN|LCM_TCP_ACK, g_pstRsock[s].lcl_port, g_pstRsock[s].tcp_seq, 
	                       g_pstRsock[s].tcp_ack, &addr );

	        lcm_send_tcp_signal_by_if( g_pstRsock[s].if_index, LCM_TCP_RESET, g_pstRsock[s].lcl_port, g_pstRsock[s].tcp_seq, 
	                       g_pstRsock[s].tcp_ack, &addr );
		#else
	        lcm_send_tcp_signal_to_eth( LCM_TCP_FIN|LCM_TCP_ACK, g_pstRsock[s].lcl_port, g_pstRsock[s].tcp_seq, 
	                       g_pstRsock[s].tcp_ack, &addr );

	        lcm_send_tcp_signal_to_eth( LCM_TCP_RESET, g_pstRsock[s].lcl_port, g_pstRsock[s].tcp_seq, 
	                       g_pstRsock[s].tcp_ack, &addr );			
		#endif
        if( g_ulRsockDbgFlag )
        {

            aos_printf( MPE_RSOCK, "RSOCK(%u): send fin ack / reset to %A %u", s, g_pstRsock[s].peer_ip, g_pstRsock[s].peer_port );
        }
    }
    if( NULL != g_pstRsock[s].tcp_tmr )
    {
        aos_timer_stop( &g_pstRsock[s].tcp_tmr );
    }

    rsock_free( &g_pstRsock[s] );
    return AOS_SUCC;
}

VOID rsock_close_all( )
{
    RSOCK r;
    
    for( r = 0; r < MAX_RSOCK_NUM; r++ )
    {
        if( g_pstRsock[r].init )
        {
            if( 0 == (r % 500 ) )
            {
                clear_watch_dog();
            }            
            rsock_close(r);
        }
    }
}

U32 rsock_send( RSOCK s, MBUF_S *mbuf )
{
    U32          ulResult, seq, ack;
    TCPIPHDR_S   *tcpip;
	IP_S         *ip;
	UDPHDR_S     *udp;
    IFNET_S	     *ifp;
	ROUTE_S	      route;
    U32           nexthop = 0;
    U16           len;
    U32           ulRet;

    if( NULL == mbuf )
    {
		AOS_ASSERT(0);
        return AOS_FAIL;
    }
    
    if( s < 0 || s >= MAX_RSOCK_NUM || !g_pstRsock[s].init )
    {
		mbuf_destroy(mbuf);
		AOS_ASSERT(0);
        return RSOCK_ERR;
    }

    len = (U16)MBUF_GET_TOTAL_DATA_LENGTH(mbuf);

#if( CONFIG_BOARD_GMPU == TRUE )
    if( ( g_ulRsGateWay[0] || g_ulRsGateWay[1] )
      && g_pstRsock[s].if_index )
    {
    	ifp = if_get_if_by_index(g_pstRsock[s].if_index);
    	if (NULL == ifp || NULL == ifp->if_pfOutput)
    	{
    		mbuf_destroy(mbuf);
    		AOS_ASSERT(0);
            g_pstRsock[s].if_index = 0; 
            return AOS_FAIL;
    	}
    	if (ifp->if_ulPhyType == PHY_LOOP)
    	{
    		mbuf_destroy(mbuf);
    		AOS_ASSERT(0);
            return AOS_FAIL;
    	}
        if( ( g_pstRsock[s].peer_ip & ifp->if_ulIpMask )
         == ( ifp->if_ulIpAddr & ifp->if_ulIpMask ) )
        {
            
            nexthop = g_pstRsock[s].peer_ip;
        }
        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 = g_pstRsock[s].peer_ip;
        rt_alloc(&route);
        if (NULL == route.ro_pRt)
        {
    		mbuf_destroy(mbuf);
    		aos_printf( MPE_RSOCK, "LCM RSOCK: No Route to %A", g_pstRsock[s].peer_ip );
            return AOS_FAIL;
        }
    	ifp = if_get_if_by_index(route.ro_pRt->rt_ulIfIndex);
    	if (NULL == ifp || NULL == ifp->if_pfOutput)
    	{
    		mbuf_destroy(mbuf);
    		AOS_ASSERT(0);
            return AOS_FAIL;
    	}

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

    	if (RT_FIELD_FLAGS(route.ro_pRt) & RTF_GATEWAY)
    	{
    		nexthop = RT_FIELD_GATEWAY(route.ro_pRt);
    	}
        else
        {
            nexthop = g_pstRsock[s].peer_ip;
        }
    }

    if( RSOCK_PROTO_TCP == g_pstRsock[s].proto )
    {
        
    	MBUF_PREPEND_MEMORY_SPACE(mbuf, sizeof(TCPIPHDR_S), MPE_RSOCK, ulResult);
    	if (MBUF_OK != ulResult)
    	{
    		mbuf_destroy(mbuf);
    		AOS_ASSERT(0);
            return AOS_FAIL;
    	}
        MBUF_COMPRESS( mbuf, 1 , MPE_RSOCK , ulRet);
        if( AOS_SUCC != ulRet )
        {
    		mbuf_destroy(mbuf);
    		AOS_ASSERT(0);
            return AOS_FAIL;
        }

        seq = AOS_HTONL(g_pstRsock[s].tcp_seq);
        ack = AOS_HTONL(g_pstRsock[s].tcp_ack);
        g_pstRsock[s].tcp_seq += len;
        g_pstRsock[s].tcp_last_ack = g_pstRsock[s].tcp_ack;

    	
    	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(sizeof(TCPHDR_S) + len);
        aos_memcpy((U8*)&tcpip->seqTHSeq, (U8*)&seq, 4);
        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(g_pstRsock[s].lcl_port);
    	tcpip->usTHDstPort = AOS_HTONS(g_pstRsock[s].peer_port);
        aos_memcpy(&tcpip->adrIHSrc.s_ulAddr, & ifp->if_ulIpAddr, 4);
        aos_memcpy(&tcpip->adrIHDst.s_ulAddr, &g_pstRsock[s].peer_ip, 4);
    	tcpip->usTHCheckSum = in_cksum(mbuf, (S32)( sizeof(TCPIPHDR_S)+ len));

        len += sizeof(TCPIPHDR_S);
    }
    else
    {
        
    	MBUF_PREPEND_MEMORY_SPACE(mbuf, sizeof(UDPHDR_S)+sizeof(IP_S), MPE_RSOCK, ulResult);
    	if (MBUF_OK != ulResult)
    	{
    		mbuf_destroy(mbuf);
    		AOS_ASSERT(0);
            return AOS_FAIL;
    	}
        MBUF_COMPRESS( mbuf, 1 , MPE_RSOCK, ulRet );
        if( AOS_SUCC != ulRet )
        {
    		mbuf_destroy(mbuf);
    		AOS_ASSERT(0);
            return AOS_FAIL;
        }
        
		ip = MBUF_MTOD(mbuf, IP_S*);
		udp = (UDPHDR_S*)(ip+1);

		udp->uh_usSPort = AOS_HTONS(g_pstRsock[s].lcl_port);
		udp->uh_usDPort = AOS_HTONS(g_pstRsock[s].peer_port);
		udp->uh_sULen   = (S16)AOS_HTONS(sizeof(UDPHDR_S) + len);
		udp->uh_usSum   = 0;
        udp->uh_usSum   = rtp_udp_checksum((U8*)udp
	                    , ifp->if_ulIpAddr, g_pstRsock[s].peer_ip
	                    , AOS_NTOHS(udp->uh_sULen));

 		aos_memcpy( &ip->ip_stSrc.s_ulAddr, &ifp->if_ulIpAddr, 4 );
		aos_memcpy( &ip->ip_stDst.s_ulAddr, &g_pstRsock[s].peer_ip, 4 );
		ip->ip_chPr = IPPROTO_UDP;

        len += sizeof(UDPIPHDR_S);
    }

    
	ip = MBUF_MTOD(mbuf, IP_S*);
	ip->ip_chHLen = 5;
    ip->ip_chVer  = 4;
    ip->ip_usLen  = AOS_HTONS(len);
    ip->ip_chTTL  = 128;
    ip->ip_chTOS  = 0;		
    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;

    NAT_SET_FLAG(mbuf,NAT_VOX);
    
	if (ifp->if_pfLLCOutput(mbuf))
	{
	}
    
    return AOS_SUCC;
}

U32 rsock_packet_input( RSOCK s, U8 *buf, U32 if_index )
{
    IP_S     *ip;
    TCPHDR_S *tcp = NULL;
    UDPHDR_S *udp = NULL;
    U32      tcpSeq,tcpAck,srcIp;
    U16      lclPort, srcPort, payLen = 0;
    SOCKADDRIN_S addr;
    U32          rsock_proto;
    rsock_t      *rs;

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

	ip = (IP_S*)buf;
    aos_memcpy( &srcIp, &ip->ip_stSrc.s_ulAddr, 4 );

    if( IPPROTO_TCP == ip->ip_chPr )
    {
        tcp = (TCPHDR_S*)((U8*)ip + (ip->ip_chHLen << 2));
        aos_memcpy( &tcpSeq, &tcp->seqSeqNumber, 4 );
        aos_memcpy( &tcpAck, &tcp->seqAckNumber, 4 );

        tcpSeq = AOS_NTOHL(tcpSeq);
        tcpAck = AOS_NTOHL(tcpAck);
        srcPort = AOS_NTOHS( tcp->usSrcPort );
        lclPort = AOS_NTOHS( tcp->usDstPort );

        payLen = AOS_NTOHS(ip->ip_usLen) - ( ip->ip_chHLen << 2 ) - ( tcp->ucOffset << 2 );
        rsock_proto = RSOCK_PROTO_TCP;
    }
    else
    {
        udp = (UDPHDR_S*)((U8*)ip + (ip->ip_chHLen << 2));
        srcPort = AOS_NTOHS( udp->uh_usSPort );
        lclPort = AOS_NTOHS( udp->uh_usDPort );
        rsock_proto = RSOCK_PROTO_UDP;

        payLen = AOS_NTOHS(ip->ip_usLen) - ( ip->ip_chHLen << 2 ) - 8;
		
    }

    if( NULL_RSOCK == s )
    {
        s = rsock_find( rsock_proto, srcIp, srcPort, lclPort, if_index);
        if( RSOCK_PROTO_TCP == rsock_proto 
         && NULL_RSOCK == s 
         && LCM_TCP_SYN == tcp->ucFlags )
        {
            s = rsock_init( RSOCK_PROTO_TCP, srcIp, srcPort, lclPort, if_index, 0, NULL );
            if( NULL_RSOCK != s )
            {
                g_pstRsock[s].ref = 0;
                g_pstRsock[s].is_tcp_server = 1;
                aos_timer_start( &g_pstRsock[s].tcp_tmr, 
                                 MPE_RSOCK,
                                 RSOCK_SYN_RECV_TIMER_LEN,
                                 RSOCK_SYN_RECV_TIMER,
                                 s,
                                 AOS_TIMER_NO_LOOP );
                if( g_ulRsockDbgFlag )
                {
                    aos_printf( MPE_RSOCK, "RSOCK(%u): port %u Create a rsock in listening from %A %u", 
                        s, lclPort, srcIp, srcPort );
                }
            }
        }
        if( NULL_RSOCK == s )