Exemple #1
0
VMINT vm_tls_delete_ctx(VMINT res_id)
{
    kal_int32 ret;
    vm_tls_context_t * ctx_p = NULL;

    MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_S, 21, __LINE__);
    ctx_p = vm_tls_get_ctx_by_res(res_id);
    if (NULL == ctx_p)
    {
        MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_E1, 21, __LINE__);
        return VM_TLS_RET_BASE -2;
    }

    ret = tls_delete_ctx(ctx_p->tls_ctx);
    vm_tls_free_ctx(ctx_p);

    
    if (0 == --g_ref_count)
    {
        mmi_frm_clear_protocol_event_handler(MSG_ID_APP_SOC_NOTIFY_IND, (PsIntFuncPtr)vm_tls_notify_cb);
        mmi_frm_clear_protocol_event_handler(MSG_ID_APP_TLS_NOTIFY_IND, (PsIntFuncPtr)vm_tls_notify_ind);
        mmi_frm_clear_protocol_event_handler(MSG_ID_APP_TLS_ALERT_IND, (PsIntFuncPtr)vm_tls_alert_ind);
        mmi_frm_clear_protocol_event_handler(MSG_ID_APP_TLS_INVALID_CERT_IND, (PsIntFuncPtr)vm_tls_invalid_cert_ind);
        mmi_frm_clear_protocol_event_handler(MSG_ID_APP_TLS_CLIENT_AUTH_IND, (PsIntFuncPtr)vm_tls_client_auth_ind);
        MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_E2, 21, __LINE__);
    }

    MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_E, 21, ret);
    return ret;
}
/*****************************************************************************
 * FUNCTION
 *  avk_pluto_nvram_async_write_handler
 * DESCRIPTION
 *  handler for async write response
 * PARAMETERS
 *  write_cnf : [IN]  nvram write response
 * RETURNS
 *  0 : for protocal event, to diliver msg for other listener
 *  1 : stop diliver the msg for other listener
 *****************************************************************************/
static U8 avk_pluto_nvram_async_write_handler(void *write_cnf)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    nvram_write_cnf_struct *nvram_write_cnf;
    S16 error;
    S32 ret, i;
    U8 buff[AVK_PLUTO_NVRAM_TEST_REC_SIZE];
    
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    nvram_write_cnf = (nvram_write_cnf_struct *)write_cnf;
    if (nvram_write_cnf->file_idx == AVK_PLUTO_NVRAM_TEST_REC_LID)
    { 
        mmi_frm_clear_protocol_event_handler(MSG_ID_NVRAM_WRITE_CNF, avk_pluto_nvram_async_write_handler);
        MMI_ASSERT(nvram_write_cnf->result == NVRAM_IO_ERRNO_OK);
        memset(buff, AVK_PLUTO_NVRAM_TEST_DATA_VAL + 10, AVK_PLUTO_NVRAM_TEST_REC_SIZE);
        ret = ReadRecord(AVK_PLUTO_NVRAM_TEST_REC_LID, 1, buff, AVK_PLUTO_NVRAM_TEST_REC_SIZE, &error);
        MMI_ASSERT((ret == AVK_PLUTO_NVRAM_TEST_REC_SIZE) && (error == NVRAM_READ_SUCCESS));
        for (i = 0; i < AVK_PLUTO_NVRAM_TEST_REC_SIZE; i++)
        {
            MMI_ASSERT(buff[i] == AVK_PLUTO_NVRAM_TEST_DATA_VAL);
        }
        ret = WriteRecord(AVK_PLUTO_NVRAM_TEST_REC_LID, 1, g_avk_pluto_nvram_cntx.buff_backup, AVK_PLUTO_NVRAM_TEST_REC_SIZE, &error);
        MMI_ASSERT((ret == AVK_PLUTO_NVRAM_TEST_REC_SIZE) && (error == NVRAM_WRITE_SUCCESS));
        AVK_CASE_RESULT(MMI_TRUE);
        AVK_ASYN_DONE();
        return 1;
    }
    return 0;
}
static MMI_BOOL mmi_ssc_set_imei(void *buf)
{
    U8 tempbufimei[(MAX_IMEI_LEN + 1) * ENCODING_LENGTH];
	#ifdef __MMI_IMEISV_SUPPORT__
	U8 tempbufsvn[(MAX_IMEI_LEN + 1) * ENCODING_LENGTH];
	#endif
	//U8 tempbuf[(MAX_IMEI_LEN + 1) * ENCODING_LENGTH];
    mmi_nw_get_imei_rsp_struct *imeiresponse = (mmi_nw_get_imei_rsp_struct*) buf;
        
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    mmi_frm_clear_protocol_event_handler(MSG_ID_MMI_NW_GET_IMEI_RSP, NULL);
     
    if (imeiresponse->result == 1)
    {
    #if 0
    #ifdef __ASCII
/* under construction !*/
    #endif 
/* under construction !*/
    #ifdef __UCS2_ENCODING
    #ifdef __MMI_IMEISV_SUPPORT__
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
    #else /* __MMI_IMEISV_SUPPORT__ */ 
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
    #endif /* __MMI_IMEISV_SUPPORT__ */
    #endif /* __UCS2_ENCODING */
	#else
	
     #ifdef __UCS2_ENCODING
		mmi_asc_to_ucs2((CHAR*) tempbufimei, (CHAR*) imeiresponse->imei);
	 
       #ifdef __MMI_IMEISV_SUPPORT__
		mmi_asc_to_ucs2((CHAR*) tempbufsvn, (CHAR*) imeiresponse->svn);
		kal_wsprintf((WCHAR *) gstrIMEI,"%wIMEI:%w\nSVN:%w\n",gstrIMEI,tempbufimei,tempbufsvn);
		#else
		kal_wsprintf((WCHAR *) gstrIMEI,"%wIMEI:%w\n",gstrIMEI,tempbufimei);
		#endif
	#endif
		
	#endif

        return MMI_TRUE;
    }
    else
    {
        return MMI_FALSE;
    }
}
srv_ies_result srv_ies_job_deinit(srv_ies_app_session_handle hApp)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    srv_ies_job             *pJob;
    kal_int32               index;
    SRV_IES_JOB_STATE_ENUM  state;
    kal_uint32              taskID;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    hApp->appState &= ~SRV_IES_APP_STATE_JOB_INITED;

    for (index = 0; index < SRV_IES_JOB_MAX_JOB_COUNT; index++)
    {
        kal_take_mutex(g_srv_ies_hdl_mutex);
        pJob = g_srv_ies_curr_job[index];
        kal_give_mutex(g_srv_ies_hdl_mutex);
        if (pJob)
        {
            kal_take_mutex(g_srv_ies_job_mutex);
            state = pJob->state;
            kal_give_mutex(g_srv_ies_job_mutex);

            if ((pJob->pParent == hApp) &&
                (SRV_IES_JOB_STATE_INVALID  != state) &&
                (SRV_IES_JOB_STATE_FINISHED != state))
            {
                srv_ies_job_cancel(pJob);
            }
            else if ((pJob->pParent == hApp) &&
                     (SRV_IES_JOB_STATE_FINISHED == state))
            {
               g_srv_ies_curr_job[index] = NULL;
               pJob->seqNum = 0;
               TYPED_FREE(pJob, srv_ies_job);
            }

            pJob->state = SRV_IES_JOB_STATE_INVALID;
        }
    }

    kal_take_mutex(g_srv_ies_hdl_mutex);

    g_srv_ies_job_user--;
    ASSERT(g_srv_ies_job_user >= 0);

    if (0 == g_srv_ies_job_user)
    {
        kal_get_my_task_index(&taskID);
        if(INDX_MMI == taskID)
        {
            mmi_frm_clear_protocol_event_handler(MSG_ID_IES_JOB_RSP,
                                                 &_srv_ies_job_response_handler);
        }

        g_srv_ies_job_deinit = KAL_TRUE;
    }
    kal_give_mutex(g_srv_ies_hdl_mutex);

    return SRV_IES_OK;
}