コード例 #1
0
U8 ntyCellClose(void) {
    ClearProtocolEventHandler(MSG_ID_L4C_NBR_CELL_INFO_IND);
    ClearProtocolEventHandler(MSG_ID_L4C_NBR_CELL_INFO_REG_CNF);
    mmi_frm_send_ilm(MOD_L4C, MSG_ID_L4C_NBR_CELL_INFO_DEREG_REQ, NULL, NULL);
    flg_lbs_init = 0;
    return 0;
}
コード例 #2
0
ファイル: gcj_net.c プロジェクト: jprothwell/sc-fix
int gcj_StopGprs()
{
	ClearProtocolEventHandler(MSG_ID_MMI_NW_GPRS_CONNECTED_RSP);
#ifdef __MMI_MULTI_SIM__	
	ClearSlaveProtocolEventHandler(MSG_ID_MMI_NW_GPRS_CONNECTED_RSP);
#endif
	ClearProtocolEventHandler(MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND);
	int ret = soc_StopGPRS();
	return ret;
}
コード例 #3
0
ファイル: MExE.c プロジェクト: 12019/mtktest
void mmi_mexe_read_rpk_instance_rsp(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmi_smu_read_sim_rsp_struct *rpk_instance;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    rpk_instance = (mmi_smu_read_sim_rsp_struct*) info;

    ClearProtocolEventHandler(PRT_MMI_SMU_READ_SIM_RSP);

    memcpy(g_MExE_context.certificate_data + (g_MExE_context.certificate_file_read_cycle * 256), rpk_instance->data, rpk_instance->length);

    // need to read many cycles
    if (g_MExE_context.certificate_file_total_cycle == g_MExE_context.certificate_file_read_cycle)
    {
        mmi_mexe_send_sim_certificate_record_ind();
    }
    else
    {
        g_MExE_context.certificate_file_read_cycle++;
        mmi_mexe_read_rpk_instance_req();
    }
}
コード例 #4
0
ファイル: SPDI.c プロジェクト: 12019/mtktest
/*****************************************************************************
 * FUNCTION
 *  mmi_idle_get_spdi_info_rsp
 * DESCRIPTION
 *  Response of read EF_SPDI info
 * PARAMETERS
 *  info            [IN]     
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_idle_get_spdi_info_rsp(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmi_smu_read_file_info_rsp_struct *spdi_info;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    spdi_info = (mmi_smu_read_file_info_rsp_struct*) (info);
    memset(&g_spdi_info[0][0], 0, sizeof (g_spdi_info));

    ClearProtocolEventHandler(PRT_MMI_SMU_READ_FILE_INFO_RSP);

#ifdef __GEMINI__
    if (spdi_info->result.flag == 0 && sim_service_table_query(SERVICE_SP_DSPL_INFO, SIM1) == SERVICE_SUPPORT)
#else
    if (spdi_info->result.flag == 0 && sim_service_table_query(SERVICE_SP_DSPL_INFO) == SERVICE_SUPPORT)
#endif
    {
        mmi_idle_get_spdi_data_req(spdi_info->file_size);
    }
    else
    {
        g_spdi_number = 0;
        mmi_eons_init();
    }
}
コード例 #5
0
ファイル: gcj_net.c プロジェクト: jprothwell/sc-fix
static void gcjDnsEvent(void * inMsg)
{
    app_soc_get_host_by_name_ind_struct *dns_ind;
    gcj_dnsLen=0xff;
    gcj_TraceOut(0,"j2me: file %s,function %s,inMsg=%x",__FILE__,__FUNCTION__,inMsg);
    if( inMsg )
    {
        dns_ind = (app_soc_get_host_by_name_ind_struct*) inMsg;
        if (dns_ind->result == KAL_TRUE)
        {
             ClearProtocolEventHandler(MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND);
		memcpy(gcj_dnsBuff,dns_ind->addr,dns_ind->addr_len);
		gcj_dnsLen=dns_ind->addr_len;
		gcj_TraceOut(0,"j2me: file %s,function %s,,gcj_dnsLen=%d",__FILE__,__FUNCTION__,gcj_dnsLen);
        }
    }
    gcj_StubTakeMutex(&netMutex);
    _SOCKET_T *thisH = socketHead.next;
    while (thisH)
    {
    	if (thisH->isWaitForGprs)
    	{
    		gcj_StubReleaseSemphone(thisH->thisReadSem);
    		thisH->isWaitForGprs = 0;
    	}
    	thisH = thisH->next;
    }
    gcj_StubReleaseMutex(&netMutex);
}
コード例 #6
0
ファイル: CtmSrv.c プロジェクト: wangzhibinjunhua/plutommi
/*****************************************************************************
 * FUNCTION
 *  srv_ctm_rsp_close
 * DESCRIPTION
 *  
 * PARAMETERS
 *  info        [IN]     info
 * RETURNS
 *  void
 *****************************************************************************/
void srv_ctm_phdlr_close_rsp(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE(MMI_COMMON_TRC_G5_CALL, FUNC_SRV_PHDLR_CTM_CLOSE_RSP);

    ClearProtocolEventHandler(MSG_ID_MEDIA_CTM_CLOSE_CNF);

    /* open_req may be sent before the previous close_rsp is received, thus only
        clear the state when the current state is still closing */
    if (srv_ctm_p->state == SRV_CTM_STATE_CLOSING)
    {
        srv_ctm_p->state = SRV_CTM_STATE_IDLE;

        /* clear all the operation when close is completed */
        srv_ctm_p->rsp_cb = NULL;
        srv_ctm_p->curr_act = SRV_CTM_ACT_IDLE;
        srv_ctm_p->mode_opening = 0;
    }

    srv_ctm_p->mode_activated = 0;

    srv_ctm_send_ind(SRV_CTM_IND_CLOSE, NULL);

}
コード例 #7
0
ファイル: MExE.c プロジェクト: 12019/mtktest
void mmi_mexe_read_rpk_file_info_rsp(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmi_smu_read_file_info_rsp_struct *rpk_file_info;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    rpk_file_info = (mmi_smu_read_file_info_rsp_struct*) (info);

    ClearProtocolEventHandler(PRT_MMI_SMU_READ_FILE_INFO_RSP);

    if (rpk_file_info->result.flag == 0)
    {
        g_MExE_context.rpk_record_length = (U8) (rpk_file_info->file_size / rpk_file_info->num_of_rec);
        g_MExE_context.rpk_record_total = rpk_file_info->num_of_rec;
        g_MExE_context.rpk_record_read = 0;
    }
    else
    {
        /* error handler for allocated and activated file not found */
        mmi_mexe_finish_rpk_file(MMI_FALSE);
    }

    mmi_mexe_retrieve_certificate_handler();
}
コード例 #8
0
void ntyGetHostByNameIndCallback(void *inMsg) {
	NattyHttp *http = ntyHttpInstance();
	app_soc_get_host_by_name_ind_struct *dns_ind;
	//sockaddr_struct server_ip_addr;

	nty_printf("card_gps_get_host_by_name_ind_plateform \r\n");
	ClearProtocolEventHandler(MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND);
	if (!inMsg) {
		return;
	}
	dns_ind = (app_soc_get_host_by_name_ind_struct*) inMsg;
	nty_printf("card_gps_get_host_by_name_ind_plateform: len=%d: addr=%d.%d.%d.%d \r\n", dns_ind->addr_len, dns_ind->addr[0], dns_ind->addr[1], dns_ind->addr[2], dns_ind->addr[3]);
	/* Check if the result is OK */
	if (dns_ind->result == KAL_TRUE) {
		memset(&http->addr, 0x00, sizeof(sockaddr_struct));
		memcpy(http->addr.addr, dns_ind->addr, dns_ind->addr_len);
		http->addr.addr_len = dns_ind->addr_len;
		nty_printf("card_gps_get_host_by_name_ind_plateform srv_socketid\r\n");
#ifdef stu_card
		http->addr.port=80;
#else
		http->addr.port=80;
#endif
		http->addr.sock_type=0;

		ntyMMISocketAddrCopy(&http->addr, &http->addr);
		ntyHttpConnect(http);
		//gps_connect(http->socketid, &http->addr);
	} else {
	 //gprs_active= KAL_FALSE;
	 //gps_closeSocket(srv_socketid);
	 //StartTimer(ABREPEAT_BUILD_CACHE_DELAY_TIMER, 10*1000, card_conncet_to_platform);
	}
	 //plateform_connecting=0;
}
コード例 #9
0
ファイル: CtmSrv.c プロジェクト: wangzhibinjunhua/plutommi
/*****************************************************************************
 * FUNCTION
 *  mmi_ctm_connect_rsp_hdlr
 * DESCRIPTION
 *  
 * PARAMETERS
 *  info        [IN]     info
 * RETURNS
 *  void
 *****************************************************************************/
void srv_ctm_phdlr_connect_rsp(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MMI_BOOL result = MMI_TRUE;
    srv_ctm_rsp_struct rsp;
    srv_ctm_rsp_cb_func_ptr cb;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/

    ClearProtocolEventHandler(MSG_ID_MEDIA_CTM_CONNECT_CNF);

#ifndef __CTM_DEBUG
    result = (((media_ctm_connect_cnf_struct*)info)->result == MED_RES_OK) ? MMI_TRUE : MMI_FALSE;
#endif /* __CTM_DEBUG */ 

    MMI_TRACE(MMI_COMMON_TRC_G5_CALL, TRC_SRV_CTM_PHDLR_CONNECT_RSP, result, srv_ctm_p->state);
    
    if (srv_ctm_p->state == SRV_CTM_STATE_CONNECTING)
    {
         srv_ctm_p->state = result ? SRV_CTM_STATE_CONNECTED : SRV_CTM_STATE_OPENED;
    }

    cb = srv_ctm_p->rsp_cb;
    srv_ctm_p->rsp_cb = NULL;
    srv_ctm_p->curr_act = SRV_CTM_ACT_IDLE;

    /* send rsp to ctm app */
    if(cb)
    {
        rsp.result = result;
        (*cb)(&rsp);
    }

    
#ifdef __CTM_DEBUG
    StartTimer(CM_NOTIFYDURATION_TIMER, 2000, (FuncPtr) srv_ctm_phdlr_receive_text_ind);
#endif 

}
コード例 #10
0
ファイル: SyncMLHandler.c プロジェクト: 12019/mtktest
/*****************************************************************************
 * FUNCTION
 *  mmi_syncml_finish_sync_ind
 * DESCRIPTION
 *  Protocol event handler
 * PARAMETERS
 *  info        [IN]            message content
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_syncml_get_imei_rsp(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmi_nw_get_imei_rsp_struct *dataPtr = (mmi_nw_get_imei_rsp_struct*) info;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    ClearProtocolEventHandler(MSG_ID_MMI_NW_GET_IMEI_RSP);

    if (dataPtr->result == 1)
    {
        mmi_syncml_start_sync_req(dataPtr->imei);
    }
    else
    {
        MMI_ASSERT(0);
    }
}
コード例 #11
0
void MTPNP_PFAL_boot_up(void * inMsg)
{
    if (MTPNP_AD_Get_Card1Status() > 0x0 &&
            MTPNP_AD_Get_Card2Status() > 0x0)
    {
        ClearProtocolEventHandler(MSG_ID_MTPNP_WAIT_DUALSIM_READY);
        FlightModeCheckBeforeAnimation();
    }
    else
    {
        MYQUEUE Message;

        SetProtocolEventHandler(MTPNP_PFAL_boot_up, MSG_ID_MTPNP_WAIT_DUALSIM_READY);
        Message.oslSrcId = MOD_MMI;
        Message.oslDestId = MOD_MMI;
        Message.oslMsgId = MSG_ID_MTPNP_WAIT_DUALSIM_READY;
        Message.oslDataPtr = NULL;
        Message.oslPeerBuffPtr = NULL;
        OslMsgSendExtQueue(&Message);
    }
}
コード例 #12
0
ファイル: SPDI.c プロジェクト: 12019/mtktest
/*****************************************************************************
 * FUNCTION
 *  mmi_idle_get_spdi_data_rsp
 * DESCRIPTION
 *  Response of read EF_SPDI data
 * PARAMETERS
 *  info            [IN]     
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_idle_get_spdi_data_rsp(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmi_smu_read_sim_rsp_struct *spdi_data;
    U8 spdi_offset = 4;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    spdi_data = (mmi_smu_read_sim_rsp_struct*) info;

    ClearProtocolEventHandler(PRT_MMI_SMU_READ_SIM_RSP);

    if (spdi_data->result.flag == 0)
    {
        memcpy(&g_spdi_info[0][0], &spdi_data->data[spdi_offset], spdi_data->data[spdi_offset - 1]);
    }

    mmi_eons_init();
}
コード例 #13
0
ファイル: CtmSrv.c プロジェクト: wangzhibinjunhua/plutommi
/*****************************************************************************
 * FUNCTION
 *  srv_ctm_phdlr_open_rsp
 * DESCRIPTION
 *  
 * PARAMETERS
 *  info        [IN]     info
 * RETURNS
 *  void
 *****************************************************************************/
void srv_ctm_phdlr_open_rsp(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MMI_BOOL result = MMI_TRUE;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/

    ClearProtocolEventHandler(MSG_ID_MEDIA_CTM_OPEN_CNF);

    if ((srv_ctm_p->state != SRV_CTM_STATE_OPENING)
        && (srv_ctm_p->state != SRV_CTM_STATE_IDLE))
    {
        /* ignore if ctm is not opening */
        /* the state may be idle if close rsp arrives before open rsp (switch tty status) */
        MMI_TRACE(MMI_COMMON_TRC_G5_CALL, TRC_SRV_CTM_PHDLR_OPEN_RSP_IGNORE, srv_ctm_p->state);
        return;
    }


    if (((media_ctm_open_cnf_struct*)info)->result == MED_RES_OK)
    {
        /* open OK */
        MMI_TRACE(MMI_COMMON_TRC_G5_CALL, TRC_SRV_CTM_PHDLR_OPEN_RSP_SUC);

        srv_ctm_p->state = SRV_CTM_STATE_OPENED;
        srv_ctm_p->mode_activated = srv_ctm_p->mode_opening;
    }
    else
    {
        MMI_TRACE(MMI_COMMON_TRC_G5_CALL, TRC_SRV_CTM_PHDLR_OPEN_RSP_FAIL);

        srv_ctm_p->state = SRV_CTM_STATE_IDLE;
    }
}
コード例 #14
0
ファイル: MExE.c プロジェクト: 12019/mtktest
void mmi_mexe_get_sim_certificate_rsp(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    mmi_get_sim_certificate_rsp_struct *sim_certificate_rsp;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    ClearProtocolEventHandler(MSG_ID_MMI_SEND_SIM_CERTIFICATE_RECORD_RES);

    if (g_MExE_context.key_identifier != NULL)
    {
        OslMfree(g_MExE_context.key_identifier);
        g_MExE_context.key_identifier = NULL;
    }
    if (g_MExE_context.certificate_identifier != NULL)
    {
        OslMfree(g_MExE_context.certificate_identifier);
        g_MExE_context.certificate_identifier = NULL;
    }
    if (g_MExE_context.certificate_data != NULL)
    {
        OslMfree(g_MExE_context.certificate_data);
        g_MExE_context.certificate_data = NULL;
    }

    Message.oslSrcId = MOD_MMI;
    Message.oslDestId = g_MExE_context.sender_module;
    Message.oslMsgId = MSG_ID_MMI_GET_SIM_CERTIFICATE_RSP;
    sim_certificate_rsp = (mmi_get_sim_certificate_rsp_struct*) OslConstructDataPtr(sizeof(mmi_get_sim_certificate_rsp_struct));
    sim_certificate_rsp->total = g_MExE_context.idx_certificate;
    Message.oslDataPtr = (oslParaType*) sim_certificate_rsp;
    Message.oslPeerBuffPtr = NULL;
    OslMsgSendExtQueue(&Message);
}
コード例 #15
0
ファイル: MExE.c プロジェクト: 12019/mtktest
void mmi_mexe_read_service_table_rsp(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmi_smu_read_sim_rsp_struct *MExE_data;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MExE_data = (mmi_smu_read_sim_rsp_struct*) info;

    ClearProtocolEventHandler(PRT_MMI_SMU_READ_SIM_RSP);

    if (MExE_data->result.flag == 0)
    {
        if (MExE_data->data[0] & 0x03) /* 0000 0011 */
        {
            g_MExE_context.ORPK_support = MMI_TRUE;
        }

        if (MExE_data->data[0] & 0x0C) /* 0000 1100 */
        {
            g_MExE_context.ARPK_support = MMI_TRUE;
        }

        if (MExE_data->data[0] & 0x30) /* 0011 0000 */
        {
            g_MExE_context.TPRPK_support = MMI_TRUE;
        }

        if (g_MExE_context.ORPK_support || g_MExE_context.ARPK_support || g_MExE_context.TPRPK_support)
        {
            g_MExE_context.MExE_valid = MMI_TRUE;
        }
    }
}
コード例 #16
0
ファイル: CtmSrv.c プロジェクト: wangzhibinjunhua/plutommi
/*****************************************************************************
 * FUNCTION
 *  srv_ctm_phdlr_send_text_rsp
 * DESCRIPTION
 *  
 * PARAMETERS
 *  info        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void srv_ctm_phdlr_send_text_rsp(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MMI_BOOL result = MMI_TRUE;
    srv_ctm_rsp_struct rsp;
    srv_ctm_rsp_cb_func_ptr cb;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/

    ClearProtocolEventHandler(MSG_ID_MEDIA_CTM_SEND_TEXT_CNF);

#ifndef __CTM_DEBUG
    result = (((media_ctm_send_text_cnf_struct*)info)->result == MED_RES_OK) ? MMI_TRUE : MMI_FALSE;
#endif /* __CTM_DEBUG */ 

    MMI_TRACE(MMI_COMMON_TRC_G5_CALL, TRC_SRV_CTM_PHDLR_SEND_TEXT_RSP, result, srv_ctm_p->state);

    if (srv_ctm_p->state == SRV_CTM_STATE_SENDING)
    {
        srv_ctm_p->state = SRV_CTM_STATE_CONNECTED;
    }

    cb = srv_ctm_p->rsp_cb;
    srv_ctm_p->rsp_cb = NULL;
    srv_ctm_p->curr_act = SRV_CTM_ACT_IDLE;

    /* send rsp to ctm app */
    if(cb)
    {
        rsp.result = result;
        (*cb)(&rsp);
    }
}
コード例 #17
0
ファイル: MExE.c プロジェクト: 12019/mtktest
void mmi_mexe_read_rpk_file_rsp(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmi_smu_read_sim_rsp_struct *rpk_file;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    rpk_file = (mmi_smu_read_sim_rsp_struct*) info;

    ClearProtocolEventHandler(PRT_MMI_SMU_READ_SIM_RSP);

    if (rpk_file->result.flag == 0)
    {
        if ((++g_MExE_context.rpk_record_read) == g_MExE_context.rpk_record_total)
        {
            mmi_mexe_finish_rpk_file(MMI_TRUE);
        }

        if (rpk_file->data[0] == 0xFF)
        {
            /* certificate descriptor is invalid */
            mmi_mexe_retrieve_certificate_handler();
            return;
        }

        if (g_MExE_context.required_type != MExE_CERTIFICATE_ALL && g_MExE_context.required_type != rpk_file->data[2])
        {
            /* certificate type is not desired */
            mmi_mexe_retrieve_certificate_handler();
            return;
        }

        /* prepare parameters to read instance */
        memcpy(&g_MExE_context.certificate_file_id[0], &rpk_file->data[3], 2);
        g_MExE_context.certificate_file_length = rpk_file->data[7] * 256 + rpk_file->data[8];
        g_MExE_context.certificate_file_read_cycle = 0;
        if ((g_MExE_context.certificate_file_length % 256) == 0 && (g_MExE_context.certificate_file_length / 256) > 0)
        {
            g_MExE_context.certificate_file_total_cycle = g_MExE_context.certificate_file_length / 256 - 1;
        }
        else
        {
            g_MExE_context.certificate_file_total_cycle = g_MExE_context.certificate_file_length / 256;
        }

        memset(g_MExE_context.key_identifier, 0, MAX_MExE_IDENTIFIER_LEN);
        memset(g_MExE_context.certificate_identifier, 0, MAX_MExE_IDENTIFIER_LEN);

        /* keep the root public key description file */
        g_MExE_context.authority_certificate = rpk_file->data[1];
        g_MExE_context.certificate_type = rpk_file->data[2];
        g_MExE_context.key_identifier_length = rpk_file->data[9];
        memcpy(g_MExE_context.key_identifier, rpk_file->data + 10, g_MExE_context.key_identifier_length);

        if (rpk_file->data[10 + g_MExE_context.key_identifier_length] != 0 && rpk_file->data[10 + g_MExE_context.key_identifier_length] != 0xFF)
        {
            g_MExE_context.certificate_identifier_length = rpk_file->data[10 + g_MExE_context.key_identifier_length];
            memcpy(g_MExE_context.certificate_identifier, rpk_file->data + 11 + g_MExE_context.key_identifier_length, g_MExE_context.certificate_identifier_length);
        }
        else
        {
            g_MExE_context.certificate_identifier_length = 0;
        }

        mmi_mexe_read_rpk_instance_req();
    }
    else
    {
        /* error handler for allocated and activated file not found */
        mmi_mexe_finish_rpk_file(MMI_FALSE);
    }
}
コード例 #18
0
kal_int32 ntyHttpClose(int sockId) {
	soc_shutdown(sockId, SHUT_RDWR);
	soc_close(sockId);
	ClearProtocolEventHandler(MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND);
}