nq_soc_adp.c

mtk socket编程

#define __NEWSIMULATOR
#include "MMI_features.h"
#include "L4Dr1.h"
#include "ProtocolEvents.h"
#include "DebugInitDef.h"
#include "TaskInit.h"
#include "soc_api.h"
#include "FrameworkStruct.h"
#include "EventsGprot.h"
#include "TimerEvents.h"
#include "SimDetectionGprot.h"
#undef __NEWSIMULATOR

#include "nq_soc_types.h"
#include "nq_soc_adp.h"

sockaddr_struct nq_zh_sockaddr = {0};
kal_int8 nq_zh_soc_GetSIMCard1Type(void);

kal_int8 nq_zh_soc_create(kal_uint8 domain, kal_uint8 type, kal_uint8 protocol, kal_uint16 mod_id, kal_uint32 nwk_account_id)
{
	return soc_create(domain, type, protocol, mod_id, nwk_account_id);
}

kal_int8 nq_zh_soc_close(kal_int8 socketID)
{
    return soc_close(socketID);
}

void nq_zh_soc_close_account_by_id(kal_uint16 mod_id, kal_uint8 account_id)
{
	ilm_struct *ilm_send = NULL;
#if defined(MT6235)
	soc_close_nwk_account_by_id(mod_id,account_id, 0);
#else
	soc_close_nwk_account_by_id(mod_id,account_id);
#endif

	ilm_send = allocate_ilm(mod_id);
	ilm_send->msg_id = MSG_ID_APP_SOC_DEACTIVATE_REQ;
	ilm_send->peer_buff_ptr = NULL;
	ilm_send->local_para_ptr = NULL;
	SEND_ILM(mod_id, MOD_SOC, SOC_APP_SAP, ilm_send);

}

static kal_int8 nq_zh_soc_set_address(void)
{
	kal_int8		soc_ret = 0; 
	
	memset(&nq_zh_sockaddr,0,sizeof(sockaddr_struct));

	nq_zh_sockaddr.addr[0] = 10;
	nq_zh_sockaddr.addr[1] = 0;
	nq_zh_sockaddr.addr[2] = 0;
	nq_zh_sockaddr.addr[3] = 172;
	nq_zh_sockaddr.addr_len = 4;
	nq_zh_sockaddr.port = 80;
	
#if defined(MT6235)
	nq_zh_sockaddr.sock_type = SOC_SOCK_STREAM;
#elif defined(MT6225)
	nq_zh_sockaddr.sock_type = SOCK_STREAM;
#endif

	return soc_ret;
}


kal_int8 nq_zh_soc_connect(kal_int8 socketID)
{
	kal_int8 soc_ret = 0; 
	
	if((soc_ret = nq_zh_soc_set_address()) == 0)
	{
		return soc_connect(socketID, (sockaddr_struct*)&nq_zh_sockaddr);
	}

	return soc_ret;
}

kal_int32 nq_zh_soc_send(kal_int8 socketID, kal_uint8  *buf, kal_int32  len, kal_uint8 flags)
{	
	return soc_send(socketID, buf, len, flags);

}

kal_int32 nq_zh_soc_recv(kal_int8 socketID, kal_uint8 *buf, kal_int32 len, kal_uint8 flags)
{
	return soc_recv(socketID ,buf, len, flags);
}


kal_int8 nq_zh_soc_setsockopt(kal_int8 socketID, kal_uint32 option, void *val, kal_uint8  val_size)
{
    return soc_setsockopt(socketID, option, val, val_size);
}

kal_uint8 nq_zh_soc_get_default_sockopt(void)
{
	return SOC_CONNECT|SOC_READ|SOC_WRITE|SOC_CLOSE;
}

kal_uint8 nq_zh_soc_get_domain_type(void)
{
#if defined(MT6235)
	return SOC_PF_INET;
#else
	return PF_INET;
#endif
}

kal_uint8 nq_zh_soc_get_socket_type(kal_uint8 type)
{
	kal_uint8 soc_type = 0;

#if defined(MT6235)	
	switch(type)
	{
		case NQ_ZH_SOCK_STREAM:
			soc_type = SOC_SOCK_STREAM;
			break;
		case NQ_ZH_SOCK_DGRAM:
			soc_type = SOC_SOCK_DGRAM;
			break;
		case NQ_ZH_SOCK_SMS:
			soc_type = SOC_SOCK_SMS;
			break;
		case NQ_ZH_SOCK_RAW:
			soc_type = SOC_SOCK_RAW;
			break;
		default:
			assert(0);
			break;
	}
#else
	switch(type)
	{
		case NQ_ZH_SOCK_STREAM:
			soc_type = SOCK_STREAM;
			break;
		case NQ_ZH_SOCK_DGRAM:
			soc_type = SOCK_DGRAM;
			break;
		case NQ_ZH_SOCK_SMS:
			soc_type = SOCK_SMS;
			break;
		case NQ_ZH_SOCK_RAW:
			soc_type = SOCK_RAW;
			break;
		default:
			assert(0);
			break;
	}
#endif
	return soc_type;
}

 static U8 nq_zh_soc_get_chinamobile_account_id(void)
{
#if defined(__MMI_DUAL_SIM_MASTER__)
    return 10;
#else
    return 14;
#endif
}

 static U8 nq_zh_soc_get_chinaunicom_account_id(void)
 {
     return 19;
 }

kal_uint32 nq_zh_soc_get_account_id(kal_int8 socket_index)
{
	kal_uint32 account_id;
	kal_int8 sim_info = 0;
	
#ifdef __MMI_DUAL_SIM_MASTER__
	kal_uint8 app_id;
	

	sim_info = nq_zh_soc_get_simCard_info();
	app_id = cbm_register_app_id(STR_GLOBAL_OK,IMG_GLOBAL_OK); /*Encode the sim id into the account id */
	switch(sim_info)
	{
		case NQ_ZH_CHINAMOBILE:
			account_id = nq_zh_soc_get_chinamobile_account_id();
			account_id = cbm_encode_data_account_id (account_id, NQ_ALWAYS_ASK_SIM_INFO_SIM1, app_id, KAL_FALSE);
			break;
		case NQ_ZH_CHINAUNICOM:
			account_id = nq_zh_soc_get_chinaunicom_account_id();
			account_id = cbm_encode_data_account_id (account_id, NQ_ALWAYS_ASK_SIM_INFO_SIM1, app_id, KAL_FALSE);
			break;
		case NQ_ZH_CHINAMOBILE_SIM2:
			account_id = nq_zh_soc_get_chinamobile_account_id();
			account_id = cbm_encode_data_account_id (account_id, NQ_ALWAYS_ASK_SIM_INFO_SIM2, app_id, KAL_FALSE);
			break;
		case NQ_ZH_CHINAUNICOM_SIM2:
			account_id = nq_zh_soc_get_chinaunicom_account_id();
			account_id = cbm_encode_data_account_id (account_id, NQ_ALWAYS_ASK_SIM_INFO_SIM2, app_id, KAL_FALSE);
			break;
		case NQ_ZH_INVALID_SIM:
		default:
			account_id = 0xffff; //无效卡
			break;
	}
#else
	 sim_info = nq_zh_soc_get_simCard_info();
	 switch(sim_info)
	 {
	 	case NQ_ZH_CHINAMOBILE:
			account_id = nq_zh_soc_get_chinamobile_account_id();
			break;
		case NQ_ZH_CHINAUNICOM:
			account_id = nq_zh_soc_get_chinaunicom_account_id();
			break;
		case NQ_ZH_INVALID_SIM:
		default:
			account_id = 0xffff; //无效卡
			break;
	 }

#endif	

	return account_id;
	
}

kal_uint16 nq_zh_soc_get_socket_app_mod_id(void)
{
	return MOD_MMI;
}

void nq_zh_soc_set_notify_handler(PsFuncPtr nq_soc_socket_notify)
{
	SetProtocolEventHandler (nq_soc_socket_notify, MSG_ID_APP_SOC_NOTIFY_IND);

}

void nq_zh_soc_set_deactive_handler(PsFuncPtr nq_soc_socket_notify)
{
	SetProtocolEventHandler (nq_soc_socket_notify, MSG_ID_APP_SOC_DEACTIVATE_CNF);
}


kal_uint16 nq_zh_soc_get_timer_baseId(void)
{
	return NQ_FRM_TIMER_BASE;
}

void nq_zh_soc_start_timer(kal_uint16 timerID, kal_uint32 delay, NQ_zh_FuncPtr funcptr )
{
	StartTimer(timerID, delay, funcptr);
}

void nq_zh_soc_stop_timer(kal_uint16 timerID)
{
	StopTimer(timerID);
}


// 判断卡1的类型
kal_int8 nq_zh_soc_GetSIMCard1Type(void)
{
	extern S8 gHomePLMNNum[];
	if(mmi_bootup_is_nw_registration_ok()==MMI_FALSE)
	{
		return NQ_ZH_INVALID_SIM;
	}

	if (mmi_bootup_is_sim_valid() == MMI_FALSE || mmi_bootup_is_sim_removed() == MMI_TRUE)
	{
		return NQ_ZH_INVALID_SIM;
	}
	
	if((memcmp(gHomePLMNNum, "46000",5)==0)
		||(memcmp(gHomePLMNNum, "46002",5)==0))
	{
	    return NQ_ZH_CHINAMOBILE;
	}
	else if(memcmp(gHomePLMNNum, "46001",5)==0)
	{
	    return NQ_ZH_CHINAUNICOM;
	}
	else
	{
	    return NQ_ZH_INVALID_SIM;
	}
}

#if defined(__MMI_DUAL_SIM_MASTER__)

// 判断卡2的类型
kal_int8 nq_zh_soc_GetSIMCard2Type()
{
	extern S8 gHomePLMNNum2[];//by lvhongling 080512
	if(mmi_bootup_is_sim2_nw_registration_ok()==MMI_FALSE)
	{
		//BsnTrace("GetSIMCard2Type  mmi_bootup_is_sim2_nw_registration_ok");
		return NQ_ZH_INVALID_SIM;
	}
	
	if (mmi_bootup_is_sim2_valid() == MMI_FALSE || mmi_bootup_is_sim2_removed() == MMI_TRUE)
	{
		return NQ_ZH_INVALID_SIM;
	}


	if((memcmp(gHomePLMNNum2, "46000",5)==0)
		||(memcmp(gHomePLMNNum2, "46002",5)==0))
	{
	     return NQ_ZH_CHINAMOBILE_SIM2;
	}
	else if(memcmp(gHomePLMNNum2, "46001",5)==0)
	{
	    return NQ_ZH_CHINAUNICOM_SIM2;
	}
	else
	{
	    return NQ_ZH_INVALID_SIM;
	}
}
#endif

kal_int8 nq_zh_soc_get_simCard_info(void)
{
	kal_int8 simCard1 = NQ_ZH_INVALID_SIM;
	kal_int8 simCard2 = NQ_ZH_INVALID_SIM;
	U8 Select_sim;

#ifdef __MMI_DUAL_SIM_MASTER__
	Select_sim =GetCurrMultiSimMode();
	if( MAIN_N_SUB == Select_sim )
	{
		simCard1 = nq_zh_soc_GetSIMCard1Type();
		simCard2 = nq_zh_soc_GetSIMCard2Type();
	}
	else if(MAIN_ONLY== Select_sim )
	{
		simCard2=NQ_ZH_INVALID_SIM;
		simCard1 = nq_zh_soc_GetSIMCard1Type();
	}
	else if( SUB_ONLY == Select_sim )
	{
		simCard1=NQ_ZH_INVALID_SIM;
		simCard2 = nq_zh_soc_GetSIMCard2Type();
	}
#else
	simCard1 = nq_zh_soc_GetSIMCard1Type();
#endif		

	
	if(simCard1 == NQ_ZH_CHINAMOBILE)
	{
		return NQ_ZH_CHINAMOBILE;
	}
	else	if(simCard2 == NQ_ZH_CHINAMOBILE_SIM2)
	{
		return NQ_ZH_CHINAMOBILE_SIM2;
	}
	else if((simCard1 == NQ_ZH_INVALID_SIM) && (simCard2 == NQ_ZH_INVALID_SIM))
	{
		return NQ_ZH_INVALID_SIM; //两张卡都无效
	}
	else if(simCard1 == NQ_ZH_CHINAUNICOM)
	{
		return NQ_ZH_CHINAUNICOM; //sim1 联通
	}
	else if(simCard2 == NQ_ZH_CHINAUNICOM_SIM2)
	{
		return NQ_ZH_CHINAUNICOM_SIM2; //sim2 联通
	}
	else
	{
		//未知
		return NQ_ZH_INVALID_SIM;
	}
	
}




/*
* common interface
*/
void nq_zh_soc_debug(const char *fmt, ...)
{
#if !defined(WIN32) 
    {
       va_list va;
       int len;
       static char MyPrintfBuff[1024*10];
       
       va_start(va, fmt);
       len = _vsnprintf(MyPrintfBuff, 1024*10, fmt, va);
       va_end(va);
   #if 0
       kal_prompt_trace(MOD_WAP, "%s", MyPrintfBuff);
   #else
       PutUARTBytes(0, MyPrintfBuff, len);
       PutUARTBytes(0, "\r\n\r\n", 4);
   #endif
    }
#endif    
}

void nq_zh_soc_assert(char *expr, char *file, kal_uint32 line)
{
#if !defined(WIN32)
    kal_assert_fail(expr, file, line, KAL_FALSE, 0, 0, 0, NULL);
#endif
}

extern void *nq_frm_large_malloc_mem(kal_uint32 size);
extern void nq_frm_large_free_mem(void *buff);

void *nq_zh_malloc_mem(kal_uint32 size)
{
    void *ret;

#if 1
	ret = nq_frm_large_malloc_mem(size);
#else
    ret = (void *)OslMalloc(size);
#endif
    assert(ret != NULL);
    
    return ret;
}

void nq_zh_free_mem(void *buff)
{
#if 1	
	nq_frm_large_free_mem(buff);
#else
	if(buff != NULL)
	{
		OslMfree(buff);
	}
#endif
}

kal_int32 nq_zh_strnicmp(const kal_char *string1, const kal_char *string2, kal_uint32 count )
{
	kal_int32 i;
	kal_int8	a,b;

	for( i = 0; i < count; i++ )
	{
		a = string1[i];
		b = string2[i];

		if( a >= 'A' && a <= 'Z' )
			a += ('a'-'A');
		if( b >= 'A' && b <= 'Z' )
			b += ('a'-'A');

		if( a == b )
			continue;

		if( string1[i] > string2[i] )
			return (i+1);
		else
			return ((i+1)*(-1));
	}

	return 0;
}