cfg_stub.c

abstract rtos

#include "syscfg.h"

#ifdef __cplusplus
#if __cplusplus
extern "C"{
#endif 
#endif 

#include "aos.h"
#include "ifnet/if_pub.h"
#include "snmp/include/snmp_if_pub.h"
#include "ethernet/ethernet.h"
#include "mgc_pub.h"
#include "mgcp_pub.h"
#include "st_pub.h"
#include "rtp_pub.h"
#include "p2p_include.h"
#include "stun_pub.h"
#include "os/rsock.h"
#include "dsp/dspb_pub.h"
#if( CONFIG_BOARD_EIA == TRUE )
#include "cfm/cfm_pub.h"
#endif
#include "ht_include.h"

#define UDP_DETECT_PORT  65534

extern U32 stun_add_udp_to_list(MBUF_S * pstMBuf);

#if( AOS_INCLUDE_SMP_SNMP == TRUE )
extern VOID snmp_add_mib_snmp( VOID );
extern VOID snmp_add_mib_newif_mib_tree( VOID );
extern VOID snmp_add_mib_newifext_mib_tree( VOID );
extern VOID snmp_add_mib_load_tree( VOID );
extern VOID snmp_add_mib_rtm_tree( VOID );
extern VOID snmp_add_mib_ip_tree( VOID );
extern VOID snmp_add_mib_bill_tree(VOID);
extern VOID snmp_add_mib_v5_tree( VOID );
extern VOID snmp_add_mib_st_tree( VOID );
extern VOID snmp_add_mib_alarm_tree(VOID);
extern VOID snmp_add_mib_mgcp_tree(VOID);
extern VOID snmp_add_mib_device_tree();
extern VOID snmp_add_mib_cliuser_tree( VOID );
extern VOID snmp_add_mib_trace_tree( VOID );
extern VOID snmp_add_mib_log_tree( VOID );
extern VOID snmp_add_mib_patch_tree( VOID );
extern VOID	snmp_add_mib_freelink( VOID );
#if(AOS_INCLUDE_SSP_LOAD == TRUE)
extern U32   load_mib_configcallback( VOID * pMsgRcv, VOID **ppMsgSnd );
#endif
#if(AOS_INCLUDE_INET_IFNET == TRUE)
extern U32 if_snmp_call_center( VOID *pMsgRcv, VOID **ppMsgSnd );
#endif
#if(AOS_INCLUDE_INET_RTPRO_STATIC == TRUE)
extern U32 rtm_mib_mib_callBack(VOID * pMsgRcv, VOID **ppMsgSnd);
#endif
#if(AOS_INCLUDE_INET_IP == TRUE)
extern U32 ip_snmp_call_center( VOID *pMsgRcv, VOID **ppMsgSnd );
#endif

#if (AOS_INCLUDE_SERVICE_BILL == TRUE )
extern U32 bill_mib_call_back( VOID *pMsgRcv, VOID **ppMsgSnd );
extern U32 bill_cg_mib_call_back(VOID* pMsgRcv, VOID** ppMsgSnd);
#endif
#if (AOS_INCLUDE_SERVICE_ST == TRUE )
extern U32 st_proc_snmp(VOID * pMsgRcv, VOID * * ppMsgSnd);
#endif
#if (AOS_INCLUDE_SERVICE_V5 == TRUE )
extern U32 v5mib_mib_configcallback(VOID * pMsgRcv, VOID * * ppMsgSnd);
#endif
#if (AOS_INCLUDE_DEV_SERVER == TRUE )
#endif
#if (AOS_INCLUDE_SMP_ALARM == TRUE )
extern U32 alarm_mib_callback( VOID * pMsgRcv, VOID **ppMsgSnd );
#endif

#if (AOS_INCLUDE_SERVICE_MGCP_EIG_ADAPTOR == TRUE )
extern U32 mgcp_eig_snmp_call_back( VOID * pMsgRcv, VOID **ppMsgSnd );
#endif

#if ( AOS_INCLUDE_DEV_SERVER == TRUE )
extern U32 dev_mib_config_callback( VOID * pMsgRcv, VOID **ppMsgSnd );
#endif

#if ( AOS_INCLUDE_SMP_CLI == TRUE )
extern U32 cli_user_mib_callback_center( VOID * pMsgRcv, VOID **ppMsgSnd );
#endif

#if ( AOS_INCLUDE_SMP_TRACE == TRUE )
extern U32 trace_mib_callback( VOID * pMsgRcv, VOID **ppMsgSnd );
#endif

#if ( AOS_INCLUDE_SMP_LOG == TRUE )
extern U32 log_mib_callback( VOID * pMsgRcv, VOID **ppMsgSnd );
#endif

#if ( AOS_INCLUDE_SSP_PAT == TRUE )
U32 patch_mib_callback( VOID * pMsgRcv, VOID **ppMsgSnd );
#endif

#if ( AOS_INCLUDE_SERVICE_POSTBOX == TRUE )
U32 freelink_mib_configcallback( VOID * pMsgRcv, VOID **ppMsgSnd );
#endif

extern VOID fe_get_service_mac( U8 mac[] );


VOID snmp_mibtree_buildtree( )
{

    snmp_add_mib_snmp(  );

#if( AOS_INCLUDE_SSP_LOAD == TRUE )
     snmp_add_mib_load_tree();
#endif

#if (AOS_INCLUDE_INET_IFNET == TRUE)
    snmp_add_mib_newif_mib_tree();
    snmp_add_mib_newifext_mib_tree();
#endif

#if (AOS_INCLUDE_INET_RTPRO_STATIC == TRUE)
    snmp_add_mib_rtm_tree();
#endif

#if (AOS_INCLUDE_INET_IP == TRUE )
    snmp_add_mib_ip_tree();
#endif

#if (AOS_INCLUDE_SERVICE_BILL == TRUE )
    snmp_add_mib_bill_tree();
#endif

#if ( AOS_INCLUDE_SERVICE_V5 == TRUE )
    snmp_add_mib_v5_tree();
#endif
#if ( AOS_INCLUDE_SERVICE_ST == TRUE )
    snmp_add_mib_st_tree();
#endif
#if ( AOS_INCLUDE_SMP_ALARM == TRUE )
    snmp_add_mib_alarm_tree();
#endif

#if ( AOS_INCLUDE_SERVICE_MGCP_EIG_ADAPTOR == TRUE )
    snmp_add_mib_mgcp_tree();
#endif
#if ( AOS_INCLUDE_DEV_SERVER == TRUE )
    snmp_add_mib_device_tree();
#endif

#if ( AOS_INCLUDE_SMP_CLI == TRUE )
    snmp_add_mib_cliuser_tree();
#endif

#if ( AOS_INCLUDE_SMP_TRACE == TRUE )
    snmp_add_mib_trace_tree();
#endif

#if( AOS_INCLUDE_SMP_LOG == TRUE )
    snmp_add_mib_log_tree();
#endif

#if( AOS_INCLUDE_SSP_PAT == TRUE )
    snmp_add_mib_patch_tree( );

#endif

#if( AOS_INCLUDE_SERVICE_POSTBOX == TRUE )
    snmp_add_mib_freelink( );
#endif

}


VOID snmp_install_mib_modules()
{
#if(AOS_INCLUDE_SSP_LOAD == TRUE )
    snmp_if_install_module(MPE_LOAD, load_mib_configcallback);
#endif
#if(AOS_INCLUDE_INET_IFNET == TRUE )
    snmp_if_install_module(MPE_IFNET, if_snmp_call_center);
#endif
#if(AOS_INCLUDE_INET_RTPRO_STATIC == TRUE )
    snmp_if_install_module(MPE_RTM, rtm_mib_mib_callBack);
#endif
#if(AOS_INCLUDE_INET_IP == TRUE)
    snmp_if_install_module(MPE_IP, ip_snmp_call_center);
#endif
#if (AOS_INCLUDE_SERVICE_BILL == TRUE )
    snmp_if_install_module(MPE_BILL, bill_mib_call_back);
    snmp_if_install_module(MPE_BILL_CG, bill_cg_mib_call_back);
#endif

#if (AOS_INCLUDE_SERVICE_ST == TRUE )
    snmp_if_install_module(MPE_ST, st_proc_snmp);
#endif
#if (AOS_INCLUDE_SERVICE_V5 == TRUE )
    snmp_if_install_module( MPE_V5MNGT, v5mib_mib_configcallback);
#endif

#if (AOS_INCLUDE_SMP_ALARM == TRUE )
    snmp_if_install_module( MPE_ALARM, alarm_mib_callback);
#endif

#if (AOS_INCLUDE_SERVICE_MGCP_EIG_ADAPTOR == TRUE )
    snmp_if_install_module( MPE_MGCP_ADAPTOR, mgcp_eig_snmp_call_back);
#endif

#if (AOS_INCLUDE_DEV_SERVER == TRUE )
    snmp_if_install_module( MPE_DEV, dev_mib_config_callback);
#endif


#if (AOS_INCLUDE_SMP_CLI == TRUE )
    snmp_if_install_module( MPE_CLI, cli_user_mib_callback_center);
#endif

#if (AOS_INCLUDE_SMP_TRACE == TRUE )
    snmp_if_install_module( MPE_TRACE, trace_mib_callback);
#endif

#if (AOS_INCLUDE_SMP_LOG == TRUE )
    snmp_if_install_module( MPE_LOG, log_mib_callback);
#endif
#if (AOS_INCLUDE_SSP_PAT == TRUE )
    snmp_if_install_module( MPE_PAT, patch_mib_callback);
#endif

#if (AOS_INCLUDE_SERVICE_POSTBOX == TRUE )
    snmp_if_install_module( MPE_POSTBOX , freelink_mib_configcallback);
#endif
}

#endif

#if AOS_INCLUDE_SERVICE_P2P_NN == FALSE
BOOL_T p2p_is_reservport(U16 usPort)
{
    return FALSE;
}
S32 p2p_trans_evaluate_voip(VOID)
{
    return 0;
}
#endif

#if (AOS_INCLUDE_SERVICE_P2P_NN == FALSE && AOS_INCLUDE_SERVICE_P2P_SN_CN == FALSE && CONFIG_BOARD_GDSP == FALSE)
BOOL_T p2p_is_p2p_logic_port( U16 usPort )
{
	return FALSE;
}
VOID p2p_trans_stake_send( U16 usSrcPort, VOID * v_addr, MBUF_S * pMbuf )
{
    struct msg_blk *mb = NULL;
	U8	*pData = NULL;

	if( AOS_ADDR_INVALID(pMbuf) )
	{
		return;

	}

	if( AOS_ADDR_INVALID(v_addr) )
	{
        mbuf_destroy(pMbuf);
        return;
	}

	pData = MBUF_MTOD(pMbuf, U8*);
	if( AOS_ADDR_INVALID(pData) )
	{
        mbuf_destroy(pMbuf);
        return;
	}

    mb = msg_alloc();
    if( AOS_ADDR_INVALID(mb) )
    {
        mbuf_destroy(pMbuf);
        return;
    }
    mb->head    = (U8*)mem_obj_head(pData);
    mb->truelen = mem_obj_size(pData);
    mb->end     = mb->head + mb->truelen;

    mb->data = pData;
    mb->len  = MBUF_GET_TOTAL_DATA_LENGTH(pMbuf);
    mb->tail = mb->data + mb->len;

    lcm_rapid_send_to_eth_no_wrapper( usSrcPort, mb, v_addr );

	aos_dmem_free(pMbuf);
}

VOID p2p_trans_send_signal(	U16 usSrcPort, VOID * v_addr, MBUF_S * pMbuf)
{
	p2p_trans_stake_send(usSrcPort, v_addr, pMbuf);
}
VOID p2p_trans_send_voice( U16 usSrcPort, VOID * v_addr, MBUF_S * pMbuf)
{
	p2p_trans_stake_send(usSrcPort, v_addr, pMbuf);
}
VOID p2p_trans_send_direct(	U16 usSrcPort, VOID * v_addr, MBUF_S * pMbuf)
{
	p2p_trans_stake_send(usSrcPort, v_addr, pMbuf);
}
U32 p2p_trans_send_logic( U16 usConnPort, U8 *buf, U32 len )
{
	
	AOS_ASSERT(0);
	aos_dmem_free( mem_obj_head(buf) );
	return AOS_FAIL;
}
VOID p2p_trans_path_refresh(U16 usSrcPort, U32 ulDstIp, U16 usDstPort, U16 usCause)
{
	return;
}
U32 p2p_rtp_get_fn(U16 usSrcPort, U32 ulDstIp, U16 usDstPort, P2P_PATH_PARAM *stPathInfo)
{
	return U32_BUTT;
}
U32 p2p_get_src_nat_ip(U32 ulSrcIp, U16 usSrcPort)
{
	return ulSrcIp;
}

U32 p2p_trans_get_local_ip_for_device( U16 usSrcPort )
{
    return 0;
}

void p2p_refresh_dstinfo(U32 ulDstIp, U8 ucPortNum, U16 * pusPortArray)
{
    return;
}

void p2p_get_local_port(U16 * pusPortArray)
{
    return;
}
void p2p_read_local_id(U64 * pstId, U32 ulType)
{
    aos_memzero(pstId, sizeof(U64));

    return;
}
void p2p_cli_proxy_send(U64 * pstDstId, U64 * pstSnId, U8 * pszBuf, U32 ulBufLen)
{
}
U32 p2p_trans_input_handle(MBUF_S * pstMBuf)
{
    mbuf_destroy(pstMBuf);
    return AOS_SUCC;
}
void p2p_refresh_mgc_addr()
{
}

#endif

#if (CONFIG_OS_WINDOWS == TRUE && CONFIG_BOARD_EIA == TRUE)
VOID p2p_update_socket()
{
	return;
}
VOID p2p_halt_in_lan()
{
	return;
}
#endif

#if (AOS_INCLUDE_SERVICE_STUN_SERVER == FALSE && AOS_INCLUDE_SERVICE_STUN_CLIENT == FALSE)

U32 stun_get_nat_map(U16 srcport, U32 * mapip, U16 * mapport)
{
    return AOS_FAIL;
}

void stun_del_check_port(U16 usPort)
{
}

void stun_add_check_port(U16 usPort)
{
}
S8 * stun_get_nattype_str(U32 nattype)
{
    return "UNKNOWN";
}

#endif

#if (AOS_INCLUDE_SERVICE_ISVH == FALSE)
U32 rtp_is_isvh_pkt(MBUF_S *pstMBuf)
{
    return FALSE;
}

U32 rtp_isvh_input(MBUF_S *mbuf)
{
    if(AOS_ADDR_INVALID(mbuf))
    {
        mbuf_destroy(mbuf);
    }

    return AOS_SUCC;
}

#endif

extern BOOL_T rtp_is_reservport(U16 usPort);
extern BOOL_T mgcp_is_reservport(U16 usPort);
extern BOOL_T sip_is_reservport(U16 usPort);


BOOL_T lcm_is_port_reserved_for_app(U16 usPortGlobalInside)
{
#if( CONFIG_BOARD_EIA == TRUE )
    if ( rtp_is_reservport(usPortGlobalInside)
       || p2p_is_reservport(usPortGlobalInside)
       || lcm_is_reservport_without_rsock(usPortGlobalInside)
       || mgcp_is_reservport(usPortGlobalInside)
       || sip_is_reservport(usPortGlobalInside)
       )
    {
        return TRUE;
    }
#endif

    return FALSE;
}

U32 eth_is_detect_pkt(MBUF_S * pMBuf)
{
    IP_S            *ip;
    UDPHDR_S        *udp;
	U16				dst_port;
    U32             dstip;

	ip = MBUF_MTOD(pMBuf, IP_S*);

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

    if( dstip != AOS_HTONL(0x7F000001)
     && dstip != if_get_out_ip_by_ifindex( MBUF_GET_RECEIVE_IFNET_INDEX(pMBuf) )
     && AOS_HTONL(0x7F000001) != if_get_out_ip_by_ifindex( MBUF_GET_RECEIVE_IFNET_INDEX(pMBuf) ) )
    {
         return FALSE;
    }


	if (ip->ip_chHLen < 5)
	{
		
		return FALSE;
	}

    
    if(0x11 != ip->ip_chPr || AOS_NTOHS(ip->ip_usOff) &(~IP_DF))
    {
        return FALSE;
    }

	udp = (UDPHDR_S*)((U8*)ip + ip->ip_chHLen * 4);
	dst_port = AOS_NTOHS(udp->uh_usDPort);

    if(UDP_DETECT_PORT == dst_port)
    {
        return TRUE;
    }

	return FALSE;
}

extern U32		eth_send(U32  ulPhyLink,  MBUF_S *pMBuf);

U32 eth_detect_pkt_proc(MBUF_S * pMBuf)
{
    IP_S            *ip;
    UDPHDR_S        *udp;
	U16				dst_port, src_port;
    U32             dstip, srcip;

	ip = MBUF_MTOD(pMBuf, IP_S*);

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

	udp = (UDPHDR_S*)((U8*)ip + ip->ip_chHLen * 4);
	dst_port = AOS_NTOHS(udp->uh_usDPort);
	src_port = AOS_NTOHS(udp->uh_usSPort);

    udp->uh_usDPort = AOS_HTONS(src_port);
    udp->uh_usSPort = AOS_HTONS(dst_port);
    udp->uh_usSum   = 0;

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

    if_p2p_send_packet(pMBuf);

	return 0;
}


U32 eth_is_rapid_pkt( MBUF_S *pMBuf, ENQUEUE_PF *pFunc )
{
    if( aos_is_mini_system() )
    {
        return 0;
    }

	#if (AOS_INCLUDE_SERVICE_P2P_NN == TRUE || AOS_INCLUDE_SERVICE_P2P_SN_CN == TRUE)
        if(p2p_input_packet_check(pMBuf))
        {
            *pFunc = p2p_trans_input_handle;
            return 1;
        }
	#endif

    #if( AOS_INCLUDE_SERVICE_STUN_CLIENT == TRUE )
        if(stun_is_stun_patcket(pMBuf))
        {
			*pFunc = stun_add_udp_to_list;
            return 1;
        }
    #endif

    #if( CONFIG_BOARD_EIA == TRUE)
        if(rtp_eia_is_rtppacket(pMBuf))
		{
			*pFunc = rtp_eia_input;
            return 1;
		}
    #endif

	#if (CONFIG_BOARD_EIA == TRUE&& AOS_INCLUDE_SERVICE_ISVH == TRUE)
		if( rtp_is_isvh_pkt(pMBuf ) )
		{
            *pFunc = rtp_isvh_input;
            return 1;
		}
    #endif

	#if ( CONFIG_BOARD_EIA == TRUE || CONFIG_BOARD_GMPU == TRUE )
        if( TRUE == lcm_is_rapid_pkt(pMBuf) )
        {
			*pFunc = lcm_rapid_recv_from_eth;
            return 1;
        }
    #endif

    #if AOS_INCLUDE_SERVICE_TUNNEL_CLIENT == TRUE || AOS_INCLUDE_SERVICE_TUNNEL_SERVER == TRUE
        if( TRUE == tunnel_is_tunnel_packet(pMBuf) )
        {
			*pFunc = tunnel_recv_rapid_mbuf;
            return 1;
        }
    #endif

	#if ( CONFIG_BOARD_EIA == TRUE )
        if( TRUE == rsock_is_rapid_pkt(pMBuf) )
        {
			*pFunc = rsock_rapid_recv_from_eth;
            return 1;
        }
    #endif

    #if CONFIG_BOARD_GMPU == TRUE&&CONFIG_PRODUCT_EIG3000 != TRUE
        if(eth_is_detect_pkt(pMBuf))
        {
            *pFunc = eth_detect_pkt_proc;
            return 1;
        }
    #endif


    return 0;
}

U32 eth_get_out_mac( U8 mac[6] )
{
#if( CONFIG_BOARD_EIA == TRUE )
#if AOS_INCLUDE_EMUL == TRUE
    fe_get_service_mac(mac);
#else
    cfm_get_mac(0, mac);
#endif
#else
    fe_get_service_mac(mac);
#endif

    return AOS_SUCC;
}

U32 eth_get_nms_mac( U8 mac[6] )
{
#if( CONFIG_BOARD_EIA == TRUE )
    cfm_get_mac(0, mac);
#else
    fe_get_nms_mac(mac);
#endif

    return AOS_SUCC;
}

#if(  CONFIG_BOARD_EIA == TRUE )
S8* load_get_program_name()
{
#if CONFIG_OS_WINDOWS
            static S8      *filename = "eiaapp.ldf";
#else

#ifdef _EIA2000V1
#if (AOS_INCLUDE_SERVICE_SIP_UA_CLIENT == FALSE)
            static S8      *filename = "eiaapp.ldf";
#else
            static S8      *filename = "eiasipapp.ldf";
#endif
#endif

#ifdef _EIA2004V2
#if (AOS_INCLUDE_SERVICE_SIP_UA_CLIENT == FALSE)
            static S8      *filename = "eiaappv2.ldf";
#else
            static S8      *filename = "eiasipappv2.ldf";
#endif
#endif

#ifdef _EIA2000V3
#if (AOS_INCLUDE_SERVICE_SIP_UA_CLIENT == FALSE)
            static S8      *filename = "eiaappv3.ldf";
#else
            static S8      *filename = "eiasipappv3.ldf";
#endif
#endif

#ifdef _EIA2000V5
#if (AOS_INCLUDE_SERVICE_SIP_UA_CLIENT == FALSE)
           static S8      *filename = "eiaappv5.ldf";
#else
           static S8      *filename = "eiasipappv5.ldf";
#endif
#endif

#ifdef _EIA2000V7
#if (AOS_INCLUDE_SERVICE_SIP_UA_CLIENT == FALSE)
        static S8      *filename = "eiaappv7.ldf";
#else
        static S8      *filename = "eiasipappv7.ldf";
#endif
#endif


#endif

    return filename;
}
#endif

#if( AOS_INCLUDE_SERVICE_MGCP == FALSE )
BOOL_T mgcp_is_reservport(U16 usPort)
{
    return FALSE;
}
VOID mgcp_disable_register( U16 eiano )
{

}
U32 mgcp_eig_get_eia_softver(	U16   usIadNo )
{
    return 0;
}
BOOL_T mgcp_eig_is_eia_p2pv2_version(	U16   usIadNo )
{
    return FALSE;
}
SOCKADDRIN_S *mgcp_eig_get_peer_ip_port(U16 usEiaNo)
{
    static SOCKADDRIN_S addr;
    return &addr;
}
U32 mgcp_eig_get_iad_ip(U16 usEiaNo, U32 *pulIadIp, U16 *pusPort)
{
    *pulIadIp = 0;
    *pusPort  = 0;

    return AOS_FAIL;
}
U32 mgcp_eig_eia_cfg( U32 ulCmd, ROW_ID rRowID, U8 *pucOldTuple, U8 *pucNewTuple )
{
    return AOS_SUCC;
}
U32 mgcp_eig_xmt_update_udp_port(U16 usUdpPort)
{
    return AOS_SUCC;
}
U16 mgcp_get_local_udp_port( )
{
	return 0;
}
#endif

#if (AOS_INCLUDE_SERVICE_SIP_UA_SERVER == FALSE && AOS_INCLUDE_SERVICE_SIP_UA_CLIENT == FALSE&& AOS_INCLUDE_SERVICE_SIP_UA_PROXY==FALSE)
BOOL_T sip_is_reservport(U16 usPort)
{
    return FALSE;
}
void sip_net_change_proc(BOOL_T blIsConnect)
{
}
U16 sip_get_local_transport()
{
    return 0;
}
#endif

#if (AOS_INCLUDE_SERVICE_SIP_UA_SERVER == FALSE)
VOID sip_disable_register( U16 eiano )

{
}

#endif

#if (AOS_INCLUDE_SERVICE_SIP_UA_PROXY == TRUE)
void sip_app_cmd_timeout(U32 ulParam)
{
}
void sip_app_cmd_list_free(SIP_LIST_HDR_S *pstListHdr)
{
}
#endif

#if( AOS_INCLUDE_SERVICE_POSTBOX == FALSE )
void postbox_recv_mail(U32 mpe)
{
    return;
}
#endif

#if( CONFIG_BOARD_EIA == TRUE )

#if( AOS_INCLUDE_SERVICE_FAX == FALSE )
U32 faxd_get_receipt_param( U16 usPortNo )
{
    return 0;
}

#endif

#if( AOS_INCLUDE_SERVICE_RTX == FALSE )
VOID rtx_eia_register( )
{
}

VOID rtx_eia_unregister( )
{
}
#endif

#endif

#if( AOS_INCLUDE_SERVICE_NAT == FALSE )

int nat_get_htc_port(U16 *pNatport,U16 srcport)
{