cfg_stub.c

abstract rtos

    return AOS_SUCC;
}
#endif

#if( AOS_INCLUDE_DRV_T8105 == FALSE )

int net_connect(U8 ucSrcHwNo,U8 ucSrcTsNo,U8 ucDstHwNo,U8 ucDstTsNo)
{
    return AOS_SUCC;
}

VOID net_local_loop(U32 ulHwNo, U32 ulTsNo)
{
}
VOID net_remote_loop(U32 ulHwNo, U32 ulTsNo)
{
}
VOID net_delete_loop(U32 ulHwNo, U32 ulTsNo)
{
}
U32 is_eig_system()
{
    return FALSE;
}

#if CONFIG_OS_WINDOWS == FALSE
U32 T8105_isexist(void)
{
    return FALSE;
}
#endif
#endif
#if ( AOS_INCLUDE_DRIVER_E1_22554 == FALSE)
VOID e1_local_loop(U32 ulE1No, U32 ulTsNo)
{
}
VOID e1_remote_loop(U32 ulE1No, U32 ulTsNo)
{
}
VOID e1_delete_loop(U32 ulE1No, U32 ulTsNo)
{
}
#endif

#if( AOS_INCLUDE_DRIVER_E1_22554 == FALSE && CONFIG_OS_WINDOWS==FALSE)

U32 drv_hdlc_connect( U8 channel )
{
    return AOS_FAIL;
}
VOID drv_hdlc_disconnect( U8 channel )
{
}
U32 e1_chip_init (U8 chipno)
{
    return AOS_SUCC;
}

U32 e1_get_active_num(VOID)
{
    return 0;
}

VOID drv_clock_set( U8 mode, U8 e1no )
{

}

VOID drv_clock_read( U8 *mode, U8 *e1no )
{

}

VOID drv_e1_read_alarm_state( U8 e1no, U8 *linestate, U8 *errstate )
{

}

VOID drv_e1_set_loop( U8 e1no, U8 tsno, U8 loop )
{

}

U8 drv_e1_read_crc4( U8 e1no )
{
    return 0;
}

U8 drv_e1_read_loop_state( U8 e1no )
{
    return 0;
}

VOID drv_e1_set_sa7( U8 e1no, U8 sa7bit )
{

}

VOID drv_e1_check_sa7( U8 e1no )
{

}

VOID drv_e1_set_crc4( U8 e1no, U8 crc4 )
{

}

VOID drv_read_e1( VOID )
{

}

#endif


#if (AOS_INCLUDE_DRIVER_LE58021 == FALSE)
void le58021_pstn_offhook_simulate(U16 usPortID)
{
}
#endif

#if( AOS_INCLUDE_DRV_MSPD == FALSE )
U32 dsp_mspd_active_mode_trans_from_gmpu(U32 oldmode)
{
    return AOS_FAIL;
}
VOID dsp_mspd_board_miro_close_cmd( ST_BOARD_MSG *pstRcvMsg )
{

}

VOID dsp_mspd_board_miro_open_cmd( ST_BOARD_MSG *pstRcvMsg )
{
}

VOID dsp_mspd_tm_msg_proc(MSG_S *msg)
{
}

VOID dsp_mspd_set_dsp_param(U32 ulEc,U32 ulGainIn,U32 ulGainOut)
{
}
U16 dsp_mspd_get_max_dsp_num()
{
    return 1;
}
VOID dsp_mspd_modify_dsp_ability(U8 ucDspid,U16 usDspChn,U8 ucCoder,U32 ulMode)
{

}

BOOL_T dsp_mspd_get_reg_state(U8 ucDspId)
{
    return TRUE;
}
BOOL_T dsp_mspd_dsp_is_ready(U8  ucDspId )
{
    return TRUE;
}
VOID   dsp_mspd_reset_dsp_sys()
{
}
VOID dsp_mpsd_init_code_ptr(VOID)
{
}

BOOL_T dsp_mspd_get_dsp_chn_num(U32 *num, U32 *maxchan)
{
	*num = 0;
	*maxchan = 0;
	return FALSE;
}

VOID dsp_mspd_clear_reg_state(U8 ucDspId)
{

}

BOOL_T dsp_can_alloc_call(U16 usGdspTs)
{
    return TRUE;
}
BOOL_T dsp_can_alloc_call_codec(U16 usGdspTs,U8 codectype)
{
    return TRUE;
}
BOOL_T dsp_alloc_chn(U16 usGdspTs,U8 codectype)
{
    return TRUE;
}
U32 dsp_can_alloc_chn_num()
{
    return 0;
}

U32 dsp_mspd_get_macaddr(U16 usTsNo, U8 *macaddr)
{
    return AOS_SUCC;
}

U8 g_stDspMac[6];
VOID msp_api_init(void)
{
}

U16 dsp_mspd_channo(U16 gdspno)
{
    return 0;
}

U8 dsp_mspd_dspid(U16 gdspno)
{
    return 0;
}
 VOID gdsp_local_loop(U32 ulDspNo, U32 ulChnNo)
 {
 }
 VOID gdsp_remote_loop(U32 ulDspNo, U32 ulChnNo)
 {
 }
 VOID gdsp_delete_loop(U32 ulDspNo, U32 ulChnNo)
 {
 }

#if CONFIG_OS_WINDOWS == TRUE
U32 is_gmpub_board()
{
    return FALSE;
}
U8 ss7ChnTSMap[8];

U32 fe_dsp_packet_output(U32 ulDspPort,MBUF_S *pMBuf )
{
        if(AOS_ADDR_VALID(pMBuf))
        {
            mbuf_destroy(pMBuf);
        }

        return AOS_SUCC;
}

int net_disconnect(U8 ucSrcHwNo,U8 ucSrcTsNo,U8 ucDstHwNo,U8 ucDstTsNo)
{
    ucSrcHwNo = ucSrcHwNo;
    ucSrcTsNo = ucSrcTsNo;
    ucDstHwNo = ucDstHwNo;
    ucDstTsNo = ucDstTsNo;

    return AOS_SUCC;
}

int net_uniconnect(U8 ucSrcHwNo,U8 ucSrcTsNo,U8 ucDstHwNo,U8 ucDstTsNo)
{
	return AOS_SUCC;
}

void T8105_DisconnectLocalToLocal( U8 ucDstHwNo,U8 ucDstTsNo  )
{
	return ;
}


#endif

#endif

#if(AOS_INCLUDE_SERVICE_SS7 == FALSE)

BOOL_T ss7_grp_if_is_ok(U32 grpId)
{
    return FALSE;
}

BOOL_T ss7_pkt_discard(U8 channel, U32 len)
{
    return TRUE;
}
VOID ss7_trunk_reset(U32 grpId)
{
}

#endif

#if (AOS_INCLUDE_SERVICE_TUNNEL_CLIENT == FALSE && AOS_INCLUDE_SERVICE_TUNNEL_SERVER == FALSE)

U32 ht_istunnelmode()
{
	return FALSE;
}

int ht_send_msg_rapid(struct msg_blk * mb, U16 usSrcPort, U16 usDstPort)
{
	if(NULL != mb)
	{
		aos_dmem_free( (VOID*)mb->head );
	    msg_free(mb);
    }
    return -1;
}
U32 ht_istunneludp(U16 usPort)
{
    return FALSE;
}

BOOL_T ht_is_tunneludp(U32 ulIp, U16 usPort)
{
    return FALSE;
}

int ht_send_mbuf_rapid(MBUF_S *pMBuf, U16 len, U16 usSrcPort, U16 usDstPort)
{
    if(AOS_ADDR_VALID(pMBuf))
    {
        mbuf_destroy(pMBuf);
    }

    return 0;
}

U32 tunnel_get_true_iad_ip(U16 usTunnelId, U32 * ulIp)
{
    return AOS_FAIL;
}

BOOL_T htc_cfg_isrun()
{
    return 0;
}
void htc_enable_disable(U32 flag)
{
}
void htc_show_list(U32 argc , S8 *argv[])
{
}

U32 htc_get_serverip()
{
    return 0;
}
U32 htc_set_server_addr(U32 ulServerIp, U16 usServerPort)
{
    return 0;
}
U32 htc_set_proxy_addr(U32 ulProxyIp, U16 usPorxyPort)
{
    return 0;
}
void hts_show_list(U32 argc , S8 *argv[])
{
}
U32 hts_sys_int_param_cfg(DB_SYS_INT_PARAM_TBL_S *pstIntParam)
{
    return 0;
}

U32 tunnel_is_tunnel_packet(MBUF_S * pMBuf)
{
    return FALSE;
}
U32 tunnel_recv_rapid_mbuf(MBUF_S * mbuf)
{
    if(AOS_ADDR_VALID(mbuf))
    {
        mbuf_destroy(mbuf);
    }
    return AOS_SUCC;
}
#endif


#if (AOS_INCLUDE_SERVICE_NATCHECK==FALSE)

VOID nat_eig_init_handler(VOID)
{
}
#endif

#if( AOS_INCLUDE_DRIVER_I2C == FALSE )
U32 i2c_init(void)
{
    return 0;
}
U32 i2c_write(U8 DevAddr, U8 regAddr,U8 *pData, U8 DataLen )
{
    return AOS_FAIL;
}
U32 i2c_read(U8 DevAddr, U8 regAddr,U8 *pData, U8 DataLen )
{
    return AOS_FAIL;
}
#endif

#if (AOS_INCLUDE_SMP_CLI  ==   FALSE)
void cli_p2p_proxy_recv(U64 * pstSrcId, U64 * pstSnId, U8 * pszBuf, U32 ulBufLen)
{
}
#endif

#if ( CONFIG_BOARD_GDSP == TRUE )
void p2p_cli_proxy_send(U64 * pstDstId, U64 * pstSnId, U8 * pszBuf, U32 ulBufLen)
{
}
#endif

#if (AOS_INCLUDE_SERVICE_PROVISION == FALSE)
VOID prov_freelink_get()
{
}
#endif

#if(AOS_INCLUDE_SERVICE_POSTBOX == FALSE)
VOID freelink_prov_update(S8 *szXmlMail, U32 len)
{
}
U32 freelink_passport_get(S8 *szAccount, S8 *szPassword, U32 ulMaxBufLen)
{
	if( ulMaxBufLen > 0 )
	{
		szAccount[0]  = '\0';
		szPassword[0] = '\0';
	}
	return AOS_FAIL;
}
U32  freelink_build_xmlmail(char * buffer, U32 buf_len)
{
	if( buf_len > 0 )
	{
		buffer[0] = '\0';
	}
	return 0;
}
#endif

#if( CONFIG_OS_WINDOWS == TRUE )
BOOL_T dev_check_unlock_plat_pwd( S8 *pwd_str  )
{
    return TRUE;
}
BOOL_T dev_judge_is_voice_bar( U8 port_num, U8 mac[6] )
{
    return FALSE;
}
#endif

#if (AOS_INCLUDE_SMP_ALARM == FALSE)
VOID  alarm_send2back( U32 ulMpe,
                            U32 ulAlarmID,
                            U32 ulAlarmType,
                            U32 ulParaNum,
                            U32 *pulParas )
{
}
#endif

#if (AOS_INCLUDE_SMP_LOG == FALSE)
U32 log_syslog( U32 ulMpe, S8* pchLogContent )
{
    return AOS_FAIL;
}
#endif

#if (AOS_INCLUDE_SERVICE_RTPRTCP == FALSE)
BOOL_T rtp_is_reservport(U16 usPort)
{
    return FALSE;
}
U16 rtp_base_port(VOID)
{
    return 0;
}

U16 rtp_port_limit(VOID)
{
    return 0;
}

VOID rtp_fill_keep_alive(S8 *rtp_buf, U32 buf_len)
{
}

U16 rtp_in_cksum(U8*p, S32 len)
{
	S32 sum = 0, oddbyte = 0, v = 0;
	U8 *cp = p;

	
	while (len > 0) {
		if (oddbyte) {
			sum += v + *cp++;
			len--;
		}
		if (((long)cp & 1) == 0) {
			while ((len -= 2) >= 0) {
				sum += *(U16 *)cp;
				cp += 2;
			}
		} else {
			while ((len -= 2) >= 0) {
#if (CONDIF_BIG_ENDIAN == TRUE)
				sum += *cp++ << 8;
				sum += *cp++;
#else
				sum += *cp++;
				sum += *cp++ << 8;
#endif
			}
		}
		if ((oddbyte = len & 1) != 0)
#if (CONDIF_BIG_ENDIAN == TRUE)
			v = *cp << 8;
#else
			v = *cp;
#endif
	}
	if (oddbyte)
		sum += v;
	sum = (sum >> 16) + (sum & 0xffff); 
	sum += sum >> 16;		
	return (U16)(0xffff & ~sum);
}



U16 rtp_ip_cksum(U8 *p, S32 len)
{
	S32	sum = 0;
	U8	*cp = p;
	U8	*end;

	if (((U32)p & 0x1) == 0x1 || (len & 0x1) == 0x1)
	{
		return rtp_in_cksum(p, len);
	}

	end = cp + len;
	while (cp < end)
	{
		sum += *(U16 *)cp;
		cp += 2;
	}

	sum = (sum >> 16) + (sum & 0xffff);
	sum += sum >> 16;
	return (U16)(0xffff & ~sum);
}

U16 rtp_udp_checksum(U8*udpHdr, U32 srcip, U32 dstip, U16 udplen)
{
	U8	store[12];
	U8	pad=0;
	U8	*p= store;
	U8	*q = udpHdr -12;

	U16 sum;
	S32 len;
	U32 spl;

	spl = aos_int_lock();

	aos_memcpy(p, q, 4);
	aos_memcpy(p+4, q+4, 4);
	aos_memcpy(p+8, q+8, 4);

	aos_memcpy(q, (U8*)&srcip, 4);
	aos_memcpy(q+4, (U8*)&dstip, 4);
	*((U8*)(q + 8)) = 0;
	*((U8*)(q + 9)) = 17;
	*((U16*)(q + 10)) = AOS_HTONS(udplen);

	len = (udplen & 1)? udplen + 1: udplen;

	if (udplen & 1)
	{
		pad = udpHdr[udplen];
		udpHdr[udplen] = 0;
	}

	sum = rtp_ip_cksum(udpHdr - 12, len + 12);

	if (udplen & 1)
	{
		udpHdr[udplen] = pad;
	}

	aos_memcpy(q, p, 4);
	aos_memcpy(q+4, p+4, 4);
	aos_memcpy(q+8, p+8, 4);

	aos_int_unlock(spl);

	return sum;
}

U32 rtp_get_lastest_eig(VOID)
{
	return U32_BUTT;
}

U32 rtp_get_lastest_record_time(VOID)
{
	return U32_BUTT;
}

U32 rtp_get_lastest_quality(U32 ulSecLimit)
{
	return U32_BUTT;
}
U32 rtp_eia_localip(U32 *hostaddr)
{
	U32		ipaddr;

	if (NULL == hostaddr)
	{
		AOS_ASSERT(0);
		return AOS_FAIL;
	}

	(*hostaddr) = AOS_HTONL(0x7f000001);

    ipaddr = if_get_out_ipaddr();
    if(0 != ipaddr)
    {
	    (*hostaddr) = ipaddr;
    }

	return AOS_SUCC;
}

U32 md_32(U8 *string, int length)
{
	MD5_CTX context;
	union {
		U8 c[16];
		U32 x[4];
	} digest;
	U32 r;
	U32 i;

	MD5Init (&context);
	MD5Update (&context, string, length);
	MD5Final ((unsigned char *)&digest, &context);
	r = 0;
	for (i = 0; i < 3; i++)
	{
		r ^= digest.x[i];
	}
	return r;
}                               

U32 random32(U32 mixer)
{
	struct
	{
		U32	mixer;
		U32	microsec_hi;
		U32	microsec_low;
		U32	ticks;
#if (CONFIG_BOARD_EIA)
		U32	localip;
#endif
	}
	s;

	aos_time_get_ms(&s.microsec_hi, &s.microsec_low);
#if (CONFIG_BOARD_EIA)
	rtp_eia_localip(&s.localip);
#endif
	s.mixer = mixer;
	s.ticks = aos_tick_get();

	return md_32((U8 *)&s, sizeof(s));
}

#endif

#if(AOS_INCLUDE_SMP_SNMP == FALSE)
VOID snmp_if_free_msg ( VOID* pMsg )
{}
VOID snmp_if_set_msgerror ( VOID* pMsgSnd, U32 ulErrType, U32 ulErrParaIndex )
{}
U32 snmp_if_create_response ( VOID* pMsgRcv,  VOID**ppMsgSnd )
{
    return 0;
}
MSGOP_TYPE  snmp_if_get_opertype ( VOID* pMsgRcv )
{
    return 0;
}
U32 snmp_if_addpara2msg( VOID** ppMsgS, U32 ulOID, enum enum_SMEType SMEType,U32 ulParaData, U32 ulParaSize )
{
    return 0;
}
U32 snmp_if_get_para_sme( VOID* pMsgRcv,  U32 ulParaSeqNo )
{
    return 0;
}
U32 snmp_if_get_para_u32valbysme( VOID* pMsgRcv,  U32 ulReqsme, U32 *pulParaData)
{
    return 0;
}
U32 snmp_if_get_totalparamum ( VOID* pMsgRcv )
{
    return 0;
}
U32 snmp_if_get_msgsme ( VOID* pMsgRcv )
{
    return 0;
}
VOID snmp_trap_send_msg( VOID* pMsgS )
{}
U32 snmp_if_alloc_msg( VOID**ppMsgS )
{
    return 0;
}

#endif

#if (AOS_INCLUDE_SERVICE_ST == FALSE || AOS_INCLUDE_SMP_SNMP == FALSE)
U16 st_get_dev_eiano_by_mib_eiano(U16 usEiaNo)
{
    if(usEiaNo >= SIPP_DEV_NO_BASE_IN_DB + MAX_EIA_NUM)
    {
        AOS_ASSERT(0);
        return U16_BUTT;
    }
    
    if(usEiaNo > SIPP_DEV_NO_BASE_IN_DB)
    {
        usEiaNo = usEiaNo - SIPP_DEV_NO_BASE_IN_DB + MAX_EIA_NUM;
    }
    return usEiaNo;
}
#endif

#if (AOS_INCLUDE_SMP_SNMP == FALSE)
S8 g_szSnmpCliIp[64] = "255.255.255.255";
#endif

#if (AOS_INCLUDE_SERVICE_TM == FALSE)

U32 tm_get_peer_hwts( U32 e1no,U32 tsno,U32 *pHwNo,U32 *pTsno )
{
    return AOS_FAIL;
}
#endif

#if (AOS_INCLUDE_SERVICE_ROUTE_SRV_CLIENT == FALSE)
U32 rs_get_server_ip_by_priority(U8 ucRsPriority)
{
    return 0;
}
#endif

#if ( AOS_INCLUDE_SERVICE_SDFS_FTPS == FALSE )
U32 files_is_mem_path(const S8 *szPathName)
{
    return 0;
}
#endif

#ifdef __cplusplus
#if __cplusplus
}
#endif 
#endif