void FTC_DispatchMessage(ilm_struct* ptrMsg) { ilm_struct* ptr_ilm; kal_uint16 pdu_length; kal_uint8* pdu_ptr = NULL; kal_uint16 pdu_length_new; kal_uint8* pdu_ptr_new; peer_buff_struct* peer_buff_new; if( (ptrMsg->src_mod_id == MOD_FT) ) { if(ptrMsg->peer_buff_ptr == NULL) { return; } pdu_ptr = get_pdu_ptr( ptrMsg->peer_buff_ptr, &pdu_length ); switch (ptrMsg->msg_id) { case MSG_ID_FTC_BASIC_REQ: { // do the echo operation ftc_basic_cnf_struct *ftc_ptr_loc_para; // construct a peer buffer to send to FT task if( NULL != (peer_buff_new=construct_peer_buff(pdu_length, 0, 0, TD_CTRL)) ) { pdu_ptr_new = get_pdu_ptr( peer_buff_new, &pdu_length_new ); kal_mem_cpy(pdu_ptr_new, pdu_ptr , pdu_length); peer_buff_new->pdu_len = pdu_length; } ptr_ilm = FTC_ALLOC_MSG( sizeof(ftc_basic_cnf_struct) ); if(ptr_ilm) { ptr_ilm->peer_buff_ptr = peer_buff_new; //ptrMsg->peer_buff_ptr; ftc_ptr_loc_para=(ftc_basic_cnf_struct *)(ptr_ilm->local_para_ptr); ftc_ptr_loc_para->status = FTC_CNF_OK; FTC_SEND_MSG(MOD_FTC, MOD_FT, FTC_FT_SAP, (msg_type)MSG_ID_FTC_BASIC_CNF, ptr_ilm); peer_buff_new = NULL; } break; } default: break; } } else if( (ptrMsg->src_mod_id == MOD_NVRAM) ) { } }
static void e_compass_write_nvram(E_CompassSensorCalibratedDataStruct *calibrated_data) { ilm_struct *ec_ilm_ptr = 0; void *parm_stream = 0; void *data_stream = 0; kal_uint16 pdu_len; nvram_ef_ecompass_calibration ec_nvram; module_type module_id; module_id = MOD_EC_TASK; /* for now we just save three fields */ ec_nvram.usr_moffset_x = calibrated_data->usr_moffset_x; ec_nvram.usr_moffset_y = calibrated_data->usr_moffset_y; ec_nvram.usr_moffset_z = calibrated_data->usr_moffset_z; ec_nvram.cali_result = calibrated_data->cali_result; ec_nvram.x_axis_sensitivity = calibrated_data->x_axis_sensitivity; ec_nvram.y_axis_sensitivity = calibrated_data->y_axis_sensitivity; ec_nvram.x_max = calibrated_data->x_max; ec_nvram.y_max = calibrated_data->y_max; ec_nvram.x_min = calibrated_data->x_min; ec_nvram.y_min = calibrated_data->y_min; /* E_COMPASS_DEBUG_OUTPUT("Calibrated result usr_moffset_x = %d, usr_moffset_y = %d, usr_moffset_z = %d, misc = %d", ec_nvram.usr_moffset_x, ec_nvram.usr_moffset_y, ec_nvram.usr_moffset_z, 0); */ drv_trace4(TRACE_GROUP_10, EC_NVRAM_SAVE, ec_nvram.usr_moffset_x, ec_nvram.usr_moffset_y, ec_nvram.usr_moffset_z, ec_nvram.cali_result); ec_ilm_ptr = allocate_ilm(module_id); ec_ilm_ptr->msg_id = MSG_ID_NVRAM_WRITE_REQ; parm_stream = construct_local_para(sizeof(nvram_write_req_struct), TD_CTRL); data_stream = construct_peer_buff(sizeof(nvram_ef_ecompass_calibration), 0, 0, TD_CTRL); ((nvram_write_req_struct*) parm_stream)->file_idx = NVRAM_EF_ECOMPASS_DATA_LID; ((nvram_write_req_struct*) parm_stream)->para = 1; pdu_len = sizeof(nvram_ef_ecompass_calibration); kal_mem_cpy(get_pdu_ptr(data_stream, &pdu_len), (void*)&ec_nvram, sizeof(nvram_ef_ecompass_calibration)); ec_ilm_ptr->local_para_ptr = (local_para_struct*) parm_stream; ec_ilm_ptr->peer_buff_ptr = (peer_buff_struct*) data_stream; ec_ilm_ptr->src_mod_id = module_id; ec_ilm_ptr->dest_mod_id = MOD_NVRAM; ec_ilm_ptr->sap_id = PS_NVRAM_SAP; msg_send_ext_queue(ec_ilm_ptr); }
void ft_util_get_vpa_voltage_list(const FT_UTILITY_COMMAND_REQ *req, FT_UTILITY_COMMAND_CNF *cnf, peer_buff_struct **peer_buff_ret) { DCL_HANDLE handle; PMU_CTRL_VPA_GET_VOLTAGE_LIST voltageList; handle=DclPMU_Open(DCL_PMU, FLAGS_NONE); if(DclPMU_Control(handle, VPA_GET_VOLTAGE_LIST, (DCL_CTRL_DATA_T *)&voltageList) != STATUS_OK) { cnf->status = FT_CNF_FAIL; } else { cnf->status = FT_CNF_OK; } DclPMU_Close(handle); if(cnf->status == FT_CNF_OK) { if( NULL != (*peer_buff_ret=construct_peer_buff(sizeof(FtUtilCmdCnfVpaVoltageList), 0, 0, TD_CTRL)) ) { kal_uint32 i; FtUtilCmdCnfVpaVoltageList * pdu_ptr = get_pdu_ptr( *peer_buff_ret, &((*peer_buff_ret)->pdu_len) ); if(pdu_ptr != NULL) { kal_mem_set(pdu_ptr, 0, sizeof(FtUtilCmdCnfVpaVoltageList)); for(i=0;i<voltageList.number;i++) { /****************************************************** * if the voltage is valid, pass the information to PC *****************************************************/ if(voltageList.pVoltageList[i] != PMU_VOLT_INVALID) { pdu_ptr->voltageList[pdu_ptr->validNumber] = voltageList.pVoltageList[i]; pdu_ptr->registerValue[pdu_ptr->validNumber] = i; pdu_ptr->validNumber++; } } } else { ASSERT(pdu_ptr); } } else { ASSERT(0); } } }
/***************************************************************************** * FUNCTION * nvram_send_L1_cal * DESCRIPTION * * PARAMETERS * void * RETURNS * void *****************************************************************************/ void nvram_send_L1_cal(void) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ /** * file_idx should be the first L1 element in the logical data item ID enum * Currently, L1 calibration data element is as following: * NVRAM_EF_L1_AGCPATHLOSS_LID, NVRAM_EF_L1_RAMPTABLE_GSM900_LID, * NVRAM_EF_L1_RAMPTABLE_DCS1800_LID, NVRAM_EF_L1_RAMPTABLE_PCS1900_LID, * NVRAM_EF_L1_AFCDATA_LID, VRAM_EF_L1_L1SPFC_LID, */ nvram_lid_enum file_idx; ltable_entry_struct *ldi; peer_buff_struct *peer_buf_ptr; kal_uint8 *pdu_ptr; kal_uint16 pdu_length; nvram_read_req_struct *local_data; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ local_data = (nvram_read_req_struct*) construct_local_para(sizeof(nvram_read_req_struct), TD_CTRL); for (file_idx = NVRAM_EF_L1_START; file_idx <= NVRAM_EF_L1_END; file_idx++) { if (!NVRAM_IS_LID_VALID(file_idx)) { continue; } switch(file_idx) { case NVRAM_EF_L1_AGCPATHLOSS_LID: case NVRAM_EF_L1_RAMPTABLE_GSM850_LID: case NVRAM_EF_L1_RAMPTABLE_GSM900_LID: case NVRAM_EF_L1_RAMPTABLE_DCS1800_LID: case NVRAM_EF_L1_RAMPTABLE_PCS1900_LID: #if defined(__EPSK_TX__) case NVRAM_EF_L1_EPSK_RAMPTABLE_GSM850_LID: case NVRAM_EF_L1_EPSK_RAMPTABLE_GSM900_LID: case NVRAM_EF_L1_EPSK_RAMPTABLE_DCS1800_LID: case NVRAM_EF_L1_EPSK_RAMPTABLE_PCS1900_LID: case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_GSM850_LID: case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_GSM900_LID: case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_DCS1800_LID: case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_PCS1900_LID: #endif /* __EPSK_TX__ */ case NVRAM_EF_L1_AFCDATA_LID: case NVRAM_EF_L1_TXIQ_LID: case NVRAM_EF_L1_RFSPECIALCOEF_LID: case NVRAM_EF_L1_INTERSLOT_RAMP_GSM850_LID: case NVRAM_EF_L1_INTERSLOT_RAMP_GSM900_LID: case NVRAM_EF_L1_INTERSLOT_RAMP_DCS1800_LID: case NVRAM_EF_L1_INTERSLOT_RAMP_PCS1900_LID: case NVRAM_EF_L1_CRYSTAL_AFCDATA_LID: case NVRAM_EF_L1_CRYSTAL_CAPDATA_LID: { nvram_get_data_item(ldi, file_idx); local_data->access_id = 0; local_data->file_idx = file_idx; local_data->para = 1; pdu_length = ldi->size; peer_buf_ptr = construct_peer_buff(pdu_length, 0, 0, TD_CTRL); ASSERT(peer_buf_ptr != NULL); pdu_ptr = get_pdu_ptr(peer_buf_ptr, &pdu_length); ASSERT(pdu_ptr != NULL); nvram_read_confirm (MOD_L1, nvram_read_data_item(ldi, 1, 1, pdu_ptr, pdu_length), local_data, ldi->size, peer_buf_ptr); break; } } } free_local_para((local_para_struct*) local_data); } /* end of nvram_send_L1_cal function */
static BOOL mmi_da_wps_send_set_channel_req(void) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ wps_set_channel_req_struct *set_channel_req; peer_buff_struct *peer_buff_ptr = NULL; wps_set_channel_req_var_struct set_channel_req_var; U16 len, pdu_length; U16 msg_len, ref_count; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ DA_WPS_TRACE(MMI_DA_WPS_TRACE_GROUP, MMI_DA_OMA_SEND_SET_CHANNEL_REQ); set_channel_req = (wps_set_channel_req_struct *) construct_local_para(sizeof(wps_set_channel_req_struct), TD_CTRL); msg_len = set_channel_req->msg_len; ref_count = set_channel_req->ref_count; memset(set_channel_req, 0 , sizeof(wps_set_channel_req_struct)); set_channel_req->msg_len = msg_len; set_channel_req->ref_count = ref_count; set_channel_req->use_default = KAL_TRUE; set_channel_req_var.static_header_len = len = strlen("User-Agent: ")+ strlen((S8*)da_wps_context.user_agent)+ strlen("\r\n")+ strlen(STATIC_HEADER); set_channel_req_var.static_header = get_ctrl_buffer((len+1)); sprintf((S8*)set_channel_req_var.static_header,"User-Agent: %s\r\n%s", da_wps_context.user_agent, STATIC_HEADER); pdu_length= wps_pun_var_part(WPS_PUN_SIZE,MSG_ID_WPS_SET_CHANNEL_REQ,&set_channel_req_var,NULL); if( pdu_length > 0) { peer_buff_ptr = construct_peer_buff(pdu_length, 0, 0, TD_RESET); if (wps_pun_var_part(WPS_PUN_PACK, MSG_ID_WPS_SET_CHANNEL_REQ, &set_channel_req_var, get_pdu_ptr(peer_buff_ptr, &len)) != pdu_length) { free_peer_buff(peer_buff_ptr); peer_buff_ptr = NULL; } } free_ctrl_buffer(set_channel_req_var.static_header); mmi_da_send_ilm(set_channel_req, peer_buff_ptr, MSG_ID_WPS_SET_CHANNEL_REQ, MOD_WPS); SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_set_channel_rsp, MSG_ID_WPS_SET_CHANNEL_RSP); return MMI_TRUE; }
static BOOL mmi_da_wps_send_http_req(U8 request_id, U8 http_method, S8 * url, S8 * post_data, PU16 file_path) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ wps_http_req_struct *http_req; wps_http_req_var_struct http_req_var; peer_buff_struct *peer_buff_ptr = NULL; U16 pdu_length; U16 len; FS_HANDLE hd; static S8 range_header[30]; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ DA_WPS_TRACE(MMI_DA_WPS_TRACE_GROUP, MMI_DA_OMA_SEND_HTTP_REQ, request_id); ASSERT(_da_wps_is_ready()); ASSERT(request_id < MMI_DA_WPS_REQUEST_ID_RANGE); http_req = (wps_http_req_struct *) construct_local_para(sizeof(wps_http_req_struct), TD_CTRL); http_req->channel_id = da_wps_context.channel_id; http_req->request_id = request_id + MMI_DA_WPS_REQUEST_ID_BASE; http_req->method = http_method; http_req->option = WPS_HTTP_OPTION_NO_CACHE; http_req_var.request_url_len = (kal_uint32) strlen(url); http_req_var.request_url = (kal_uint8 *) url; http_req_var.request_header_len = 0; http_req_var.request_header = NULL; if (http_method == WPS_HTTP_METHOD_POST) { ASSERT(post_data != NULL); http_req->reply_type = WPS_DATA_TYPE_BUFFER; http_req->reply_segment_len = 0; /* no use here */ http_req->post_type = WPS_DATA_TYPE_BUFFER; http_req->post_path[0] = '\0'; http_req->post_path[1] = '\0'; http_req->post_total_len = strlen(post_data); http_req->more_post = MMI_FALSE; http_req_var.post_segment_len = strlen(post_data); http_req_var.post_segment = (kal_uint8 *) post_data; http_req_var.request_header_len = strlen("Content-Type: text/plain; charset=UTF-8\r\n"); http_req_var.request_header = (kal_uint8 *)"Content-Type: text/plain; charset=UTF-8\r\n"; } else { ASSERT(file_path != NULL && mmi_ucs2strlen((S8 *) file_path) < 256); http_req->reply_type = WPS_DATA_TYPE_FILE; mmi_ucs2cpy((S8 *) http_req->reply_path, (S8 *) file_path); http_req->reply_segment_len = 0; /* no use here */ http_req->post_type = WPS_DATA_TYPE_BUFFER; http_req->post_path[0] = '\0'; http_req->post_path[1] = '\0'; http_req->post_total_len = 0; http_req->more_post = MMI_FALSE; http_req_var.post_segment_len = 0; http_req_var.post_segment = NULL; // If the target file exist, it means RESUME if ((hd = FS_Open((PU16)file_path, FS_READ_ONLY)) >= 0) { UINT file_size; FS_GetFileSize(hd, &file_size); sprintf(range_header, "Range:bytes=%d-", file_size); FS_Close(hd); http_req_var.request_header_len = strlen(range_header); http_req_var.request_header = (kal_uint8 *)range_header; } } pdu_length = wps_pun_var_part(WPS_PUN_SIZE, MSG_ID_WPS_HTTP_REQ, &http_req_var, NULL); if (pdu_length > 0) { peer_buff_ptr = construct_peer_buff(pdu_length, 0, 0, TD_RESET); if (wps_pun_var_part(WPS_PUN_PACK, MSG_ID_WPS_HTTP_REQ, &http_req_var, get_pdu_ptr(peer_buff_ptr, &len)) != pdu_length) { free_peer_buff(peer_buff_ptr); peer_buff_ptr = NULL; } } mmi_da_send_ilm(http_req, peer_buff_ptr, MSG_ID_WPS_HTTP_REQ, MOD_WPS); SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_http_rsp, MSG_ID_WPS_HTTP_RSP); SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_dl_progress_ind, MSG_ID_WPS_DL_PROGRESS_IND); SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_http_auth_ind, MSG_ID_WPS_HTTP_AUTH_IND); return MMI_TRUE; }
/***************************************************************************** * FUNCTION * phb_search_continue * DESCRIPTION * This is phb_search_continue function of PHB module. * * Note: * Only searching PHB_PHBONEBOOK and PHB_BYNUMBER can reach this function. * PARAMETERS * ilm_ptr [IN] The primitives * control_block [?] * RETURNS * void *****************************************************************************/ void phb_search_continue(ilm_struct *ilm_ptr, control_block_type *control_block) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ kal_trace(TRACE_FUNC, FUNC_PHB_SEARCH_CONT); /* It's time to write prepared dat */ if (ilm_ptr == NULL) { phb_issue_IO_read(control_block); } /* Read confirmed. Now verify the entry! */ else { /* Only PHB_BYNUMBER can reach here */ /* Query pattern is stored in local_param_ptr */ l4_addr_bcd_struct *given = (l4_addr_bcd_struct*) control_block->local_param_ptr; /* The just read back candidate is stored in control_block->data */ phb_entry_struct *candidate_entry = (phb_entry_struct*) control_block->data; l4_addr_bcd_struct *candidate = &candidate_entry->tel_number; match_result_enum result = phb_compare_tel_number(given, candidate); /** * First we have to verify the candidate. The most possible candidate is * copied into the first element of l4cphb_phb_entry_array_struct stored * in control_block->peer_buf_ptr. */ /** * Verification passed: perfect matched: CC/NDC/SN are all matched. * Finally we found it! */ if ((result == MATCH_PERFECT) || /** * Verification passed: partial matched: only NDC/SN are matched * Other candidate still have chances to match. * *Sigh*, Retain this candidate and go on verification. */ (result == MATCH_PARTIAL)) { kal_uint8 *pdu_ptr; kal_uint16 pdu_length; ++control_block->actual_count; pdu_ptr = get_pdu_ptr(control_block->peer_buf_ptr, &pdu_length); kal_mem_cpy( (phb_entry_struct*) & ((l4cphb_phb_entry_array_struct*) get_32bits_aligned_val(pdu_ptr))-> array[0], (void const*)candidate_entry, sizeof(phb_entry_struct)); if (result == MATCH_PERFECT) { (*control_block->controller) (NULL, control_block); return; } } /* *Sigh*, Continue verification. */ /* Verification complete, finally control can be returned back to controller */ /* if (control_block->actual_count > control_block->candidate_count) */ if (!phb_se_is_next_also_candidate( (name_num_index_type*) control_block->candidate_name_num_index, control_block->candidate, KAL_FALSE)) { (*control_block->controller) (NULL, control_block); } /** * Still others to verify. * Since index, total is in ensured to be in range, tested in handler(), it is uncessary * to test it here. */ else { name_num_index_type *name_num_index; data_entry_struct *data_entry; /* Set index field of next entry to read */ control_block->index = ++control_block->candidate; /** * Read specific record for verification. */ phb_control_block_set_IO(control_block, control_block->type, (kal_uint16) PHB_INVALID_VALUE, 1); /* set storage, record_index, primary_ID, and secondary_ID */ name_num_index = (name_num_index_type*) control_block->candidate_name_num_index; data_entry = &name_num_index->data_entry_table.table[name_num_index->num_index.table[control_block->candidate]. position]; if (phb_se_set_control_block( control_block, OP_READ, data_entry->storage, data_entry->record_index) == KAL_FALSE) { phb_search_err_handler(NULL, control_block); return; } control_block->proc_stage = SEARCH_CONTINUE; control_block->data = (kal_uint8*) & control_block->temp_entry; control_block->length = phb_data_desc_get_record_size(phb_data_desc_get_desc_by_ID(control_block->primary_ID, control_block->storage)); phb_issue_IO_read(control_block); return; } } } /* end of phb_search_continue */
/***************************************************************************** * FUNCTION * phb_search_handler * DESCRIPTION * This is phb_search_handler function of PHB module. * Handles write request from L4C. * PARAMETERS * ilm_ptr [IN] The primitives * control_block [?] * RETURNS * void *****************************************************************************/ void phb_search_handler(ilm_struct *ilm_ptr, control_block_type *control_block) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ kal_trace(TRACE_FUNC, FUNC_PHB_SEARCH); if (ilm_ptr != NULL) { l4cphb_search_req_struct *l4cphb_search_req; l4cphb_search_req = (l4cphb_search_req_struct*) ilm_ptr->local_para_ptr; /* Cannot allocate, means that PHB is still operating. Reject request! */ control_block = phb_alloc_control_block(); if (control_block == NULL) { phb_search_confirm(PHB_ERRNO_BUSY, 0, l4cphb_search_req->src_id, MSG_ID_INVALID_TYPE, control_block); return; } control_block->src_id = l4cphb_search_req->src_id; /* Retain msg_id */ control_block->cnf_msg_id = ilm_ptr->msg_id; if ((phb_ptr->state == PHB_STATE_READY) && ((l4cphb_search_req->type == PHB_PHONEBOOK) || (l4cphb_search_req->type == PHB_FDN) || (l4cphb_search_req->type == PHB_BDN)) && ((l4cphb_search_req->pattern_tag == PHB_BYNAME) || #ifdef __PHB_SORT_ENABLE__ (l4cphb_search_req->pattern_tag == PHB_BYNAME_EXACT) || #endif (l4cphb_search_req->pattern_tag == PHB_BYNUMBER))) { if (control_block->proc_stage == SEARCH_NONE) { kal_bool is_more_candidates; l4_name_struct *alpha_id; #ifdef __PHB_SORT_ENABLE__ l4_addr_bcd_struct *tel_number; #endif /** * Here we borrow total_piggyback to store pattern_tag. * When used!? */ /* control_block->total_piggyback = l4cphb_search_req->pattern_tag; */ control_block->total_piggyback = l4cphb_search_req->total; /* Search by name, valid for both of PHB_PHONEBOOK, PHB_FDN and PHB_BDN */ if ((l4cphb_search_req->pattern_tag == PHB_BYNAME) || (l4cphb_search_req->pattern_tag == PHB_BYNAME_EXACT)) { alpha_id = &l4cphb_search_req->pattern_value.alpha_id; control_block->candidate_name_num_index = phb_se_search_by_name( l4cphb_search_req->type, (alpha_id_type*) alpha_id, &control_block->candidate, &is_more_candidates); /** * For SEARCH_BYNAME, no candidate is impossible. * Because a nearest one is always found, * therefore candidate_count is at least 1. */ } #ifdef __PHB_SORT_ENABLE__ /* Search by telephone number, only valid for PHB_PHONEBOOK */ else if ((l4cphb_search_req->pattern_tag == PHB_BYNUMBER) && (l4cphb_search_req->type == PHB_PHONEBOOK)) { tel_number = &l4cphb_search_req->pattern_value.tel_number; control_block->candidate_name_num_index = phb_se_search_by_tel_num( l4cphb_search_req->type, tel_number, &control_block->candidate, &is_more_candidates); } #endif /* __PHB_SORT_ENABLE__ */ /* Illegal comination of parameters. */ else { phb_search_err_handler(NULL, control_block); return; } /* Search telephone number in phonebook: nvram_ef_phb_lid and ADN */ /* No candidate, great!! */ if ((control_block->candidate == (kal_uint16) PHB_INVALID_VALUE) || (control_block->candidate_name_num_index == NULL)) { control_block->actual_count = 0; phb_search_confirm( PHB_ERRNO_SUCCESS, control_block->actual_count, control_block->src_id, control_block->cnf_msg_id, control_block); return; } /* Exactly only one candidate is found! Great!! */ /** * Q: The query pattern may exceeds ALPHA_ID_DEPTH, * why NOT exact match alpha_id, then retrieves the following * entries begun from the index to that one? * * A: Though exact matching is possible, retrieves from that index is * non-sense, because the sorted array is not precise, that means * the following entries begun from that index could be erroneous. */ if (l4cphb_search_req->pattern_tag == PHB_BYNAME) { kal_uint16 index; /** * Search BYNAME, if alpha_id.name_length <= PHB_ALPHA_ID_DEPTH, * then there must be exactly one nearest hit! * * Note: hit must start from 1. */ index = control_block->candidate; if (l4cphb_search_req->total < 1) { l4cphb_search_req->total = 1; } phb_control_block_set_IO(control_block, l4cphb_search_req->type, ++index, l4cphb_search_req->total); if (phb_se_is_in_range(control_block->type, index, &control_block->total) == KAL_FALSE) { control_block->actual_count = 0; phb_search_confirm( PHB_ERRNO_FAIL, control_block->actual_count, control_block->src_id, control_block->cnf_msg_id, control_block); return; } /* Piggyback is ALWAYS required. */ /** * Now we have to transform the state to a *FAKE* read state. * The fakes status ALWAYS read from index, instead of specific record. */ /* If any critial error occured. read_err_handler will handle it. */ if (phb_read_fake(control_block, NULL) == KAL_FALSE) { return; } /* Finally, faking complete....Now continue reading */ phb_read_continue(NULL, control_block); return; } #ifdef __PHB_SORT_ENABLE__ else if (l4cphb_search_req->pattern_tag == PHB_BYNAME_EXACT) { kal_uint16 i, start, count = 0; pindex_type *name_index; data_entry_table_type *desc_table; if (l4cphb_search_req->type == PHB_PHONEBOOK) { control_block->type = l4cphb_search_req->type; name_index = (pindex_type*) & phb_ptr->indices.phb_index.name_index; desc_table = (data_entry_table_type*) & phb_ptr->indices.phb_index.data_entry_table; } else { control_block->actual_count = 0; phb_search_confirm( PHB_ERRNO_FAIL, control_block->actual_count, control_block->src_id, control_block->cnf_msg_id, control_block); return; } for (i = control_block->candidate; i < name_index->used_count; i++) if (phb_is_prefix( (alpha_id_type*) & l4cphb_search_req->pattern_value.alpha_id, (alpha_id_type*) & desc_table->table[name_index->table[i].position]. alpha_id)) { break; } if (i == name_index->used_count) { /* NOT found any match */ control_block->actual_count = 0; phb_search_confirm( PHB_ERRNO_SUCCESS, control_block->actual_count, control_block->src_id, control_block->cnf_msg_id, control_block); return; } count++; start = i; for (i = start + 1; i < name_index->used_count; i++) if (phb_is_prefix( (alpha_id_type*) & l4cphb_search_req->pattern_value.alpha_id, (alpha_id_type*) & desc_table->table[name_index->table[i].position]. alpha_id)) { count++; } /* total "count" matches starting from "start" */ control_block->index = start + 1; control_block->record_index = (kal_uint16) PHB_INVALID_VALUE; if (count > 15) { count = 15; } control_block->total = count; /* If any critial error occured. read_err_handler will handle it. */ if (phb_read_fake(control_block, NULL) == KAL_FALSE) { return; } /* Finally, faking complete....Now continue reading */ phb_read_continue(NULL, control_block); return; } #endif /* __PHB_SORT_ENABLE__ */ /* For PHB_BYNAME, more than 1 candidate exists, sigh, verification is necessary */ /** * Even only exactly one candidate is found for searching BYNUMBER, * verification is still needed. */ /** * Only search of PHB_BYNUMBER can reach here. * * Candidates of searching telephone number are selected. * Now verify them. So lousy.. */ /** * Initialize hit and same_count of control_block, also * increment index to candidate, since it begins from 1. */ control_block->match_result = MATCH_FAIL; phb_search_fake( control_block, ilm_ptr, l4cphb_search_req->type, &l4cphb_search_req->pattern_value.tel_number); phb_search_continue(NULL, control_block); } /* error */ else { phb_search_err_handler(NULL, control_block); return; } } /* error, either STATE_NOT_READY or incorrect type requested for searching */ else { kal_trace(TRACE_ERROR, ERROR_PHB_STATE); if (phb_ptr->state != PHB_STATE_READY) { control_block->actual_count = 0; phb_search_confirm( PHB_ERRNO_NOT_READY, control_block->actual_count, control_block->src_id, control_block->cnf_msg_id, control_block); } else { phb_search_err_handler(NULL, control_block); } return; } } else { /* Verification over. */ if (control_block->proc_stage == SEARCH_CONTINUE) { /** * Only search of PHB_BYNUMBER can reach here. * And no piggyback is provided, so confirmation can be sent back now. * Hence, if found, actual_count is 1 and will be transfered to `total' field of * confirmation primitive; otherwise it is 0. */ /* No candidate matches! */ if (control_block->actual_count == 0) { control_block->actual_count = 0; phb_search_confirm( PHB_ERRNO_FAIL, control_block->actual_count, control_block->src_id, control_block->cnf_msg_id, control_block); } else { name_num_index_type *name_num_index = (name_num_index_type*) control_block->candidate_name_num_index; data_entry_struct *data_entry; l4cphb_phb_entry_array_struct *phb_entry_array; kal_uint8 *pdu_ptr; kal_uint16 pdu_length; data_entry = &name_num_index->data_entry_table.table[name_num_index->num_index.table[control_block->candidate]. position]; /** * To reduce code size, another possible function which * searches index to name_index by index to num_index * is not implemented . */ pdu_ptr = get_pdu_ptr(control_block->peer_buf_ptr, &pdu_length); phb_entry_array = ((l4cphb_phb_entry_array_struct*) get_32bits_aligned_val(pdu_ptr)); phb_entry_array->array[0].index = phb_se_search_by_record_index_name( control_block->type, data_entry->storage, data_entry->record_index, &data_entry->alpha_id); phb_entry_array->array[0].index++; control_block->actual_count = 1; phb_search_confirm( PHB_ERRNO_SUCCESS, control_block->actual_count, control_block->src_id, control_block->cnf_msg_id, control_block); } } /* error */ else { phb_search_err_handler(NULL, control_block); return; } } } /* end of phb_search_handler */
void das_send_file_dl_ind(das_job_t *job) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ int len; kal_uint16 length; ilm_struct *ilm_ptr = NULL; wap_mmi_file_dl_ind_struct *p; peer_buff_struct *peer_buff_ptr = NULL; wap_mmi_file_dl_var_struct var = {0}; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ p = (wap_mmi_file_dl_ind_struct*) construct_local_para(sizeof(wap_mmi_file_dl_ind_struct), TD_RESET); p->session_id = job->id; memset(p->url, 0, WAP_DL_MAX_URL_LEN); if(job->url) { len = strlen(job->url); strncpy((char *)p->url, job->url, len > WAP_DL_MAX_URL_LEN ? WAP_DL_MAX_URL_LEN : len); } memset(p->mime_type, 0, WAP_DL_MAX_MIME_TYPE_LEN); if(job->mime_type) { len = strlen(job->mime_type); strncpy((char *)p->mime_type, job->mime_type, len > WAP_DL_MAX_MIME_TYPE_LEN ? WAP_DL_MAX_MIME_TYPE_LEN : len); } memset(p->file_name, 0, WAP_DL_MAX_FILE_NAME_LEN); widget_utf8_to_ucs2_string(p->file_name, WAP_DL_MAX_FILE_NAME_LEN, (const kal_uint8 *)job->file_name); p->file_length = job->total_size; if (job->header) { var.header_len = strlen(job->header); var.header = (kal_uint8*) job->header; } else { var.header_len = 0; } if (job->buffer_tail > 0) { var.content_len = job->buffer_tail; var.content = (kal_uint8*) job->buffer; } else { var.content_len = 0; } len = wps_pun_var_part(WPS_PUN_SIZE, MSG_ID_WAP_MMI_FILE_DL_IND, (void*)&var, NULL); if (len > 0) { peer_buff_ptr = construct_peer_buff(len, 0, 0, TD_RESET); if (wps_pun_var_part (WPS_PUN_PACK, MSG_ID_WAP_MMI_FILE_DL_IND, (void*)&var, get_pdu_ptr(peer_buff_ptr, &length)) != len) { free_peer_buff(peer_buff_ptr); peer_buff_ptr = NULL; } } ilm_ptr = allocate_ilm(MOD_WAP); ilm_ptr->msg_id = (kal_uint16) MSG_ID_WAP_MMI_FILE_DL_IND; /* Set the message id */ ilm_ptr->peer_buff_ptr = peer_buff_ptr; ilm_ptr->local_para_ptr = (local_para_struct*) p; SEND_ILM(MOD_WAP, MOD_MMI, WAP_MMI_SAP, ilm_ptr); }
/***************************************************************************** * FUNCTION * das_send_dl_ind * DESCRIPTION * * PARAMETERS * mod_src [IN] * data_type [IN] * url [?] * mime_type [?] * file_name [?] * RETURNS * *****************************************************************************/ int das_send_dl_ind(MSF_UINT8 mod_src, MSF_UINT8 data_type, const char *url, const char *mime_type, const kal_uint8 *file_name, const char *header, MSF_INT32 network_account_id) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ ilm_struct *ilm_ptr = NULL; peer_buff_struct *peer_buff_ptr = NULL; mmi_da_dispatch_file_var_struct *peer_pdu = NULL; mmi_da_dispatch_file_req_struct *p; kal_uint16 length; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ p = (mmi_da_dispatch_file_req_struct*) construct_local_para(sizeof(mmi_da_dispatch_file_req_struct), TD_RESET); p->mime_type = 0; p->mime_subtype = 0; memset(p->url, 0, sizeof(p->url)); if (data_type == MsfResourceBuffer) { #ifndef __MMI_DUAL_SIM__ p->action = MMI_DA_PUSH; #else if(always_ask_get_sim_info_data_account((kal_uint32)network_account_id) == ALWAYS_ASK_SIM_INFO_SIM2) { p->action = MMI_DA_PUSH_SIM2; } else { p->action = MMI_DA_PUSH_SIM1; } #endif } else if (mod_src == MSF_MODID_SMA || mod_src == MSF_MODID_MEA) { p->action = MMI_DA_SAVE_AS; strcpy((char *)p->url, "mms://"); } else if (data_type == MsfResourceFile) { p->action = MMI_DA_SAVE_AS; } else { p->action = MMI_DA_WAP_DOWNLOAD; if (strlen(url) > 0) { strncpy((char *)p->url, url, strlen(url) > sizeof(p->url) ? sizeof(p->url) : strlen(url)); } else { strcpy((char *)p->url, "http://"); } } memset(p->filepath, 0, sizeof(p->filepath)); widget_ucs2_strcpy((kal_uint8*) p->filepath, (const kal_uint8*)file_name); strcpy((char *)p->mime_type_string, (const char*)mime_type); peer_buff_ptr = construct_peer_buff(sizeof(mmi_da_dispatch_file_var_struct) + strlen(header), 0, 0, TD_RESET); peer_pdu = (mmi_da_dispatch_file_var_struct *)get_pdu_ptr(peer_buff_ptr, &length); peer_pdu->header_len = strlen(header); memcpy(peer_pdu->header, header, peer_pdu->header_len); ilm_ptr = allocate_ilm(MOD_WAP); ilm_ptr->msg_id = (kal_uint16) MSG_ID_MMI_DA_DISPATCH_FILE_REQ; /* Set the message id */ ilm_ptr->peer_buff_ptr = peer_buff_ptr; /* there are no peer message */ ilm_ptr->local_para_ptr = (local_para_struct*) p; SEND_ILM(MOD_WAP, MOD_MMI, WAP_MMI_SAP, ilm_ptr); return 1; }
void ft_util_check_vers(FT_UTILITY_COMMAND_REQ *req, FT_UTILITY_COMMAND_CNF *cnf, peer_buff_struct **pp_peer_buff_ret) { META_UTIL_CHECK_TARGET_VER_CNF_T *p_dt = NULL; kal_uint16 pdu_length = 0; // allocate peer buffer *pp_peer_buff_ret = construct_peer_buff(sizeof(META_UTIL_CHECK_TARGET_VER_CNF_T), 0, 0, TD_CTRL); p_dt = (META_UTIL_CHECK_TARGET_VER_CNF_T *)get_pdu_ptr(*pp_peer_buff_ret, &pdu_length); kal_mem_set(p_dt, 0, sizeof(META_UTIL_CHECK_TARGET_VER_CNF_T)); if(req->cmd.m_rCheckMetaVerReq.m_eVerType == META_VERSION_META_DLL_UTIL_VER || req->cmd.m_rCheckMetaVerReq.m_eVerType == META_VERSION_USER_DEFINE) { // checkin // main version first, if >, pass the check!, if < fail, // if main version is the same, check minor version // if minor version the same, check build number if(req->cmd.m_rCheckMetaVerReq.m_u4MainVersion < FT_REQUIRED_META_DLL_MAIN_VER) { g_b_ver_Incorrect = KAL_TRUE; } else if(req->cmd.m_rCheckMetaVerReq.m_u4MainVersion == FT_REQUIRED_META_DLL_MAIN_VER) { if(req->cmd.m_rCheckMetaVerReq.m_u4MinorVersion < FT_REQUIRED_META_DLL_MINOR_VER) { g_b_ver_Incorrect = KAL_TRUE; } else if(req->cmd.m_rCheckMetaVerReq.m_u4MinorVersion == FT_REQUIRED_META_DLL_MINOR_VER) { if(req->cmd.m_rCheckMetaVerReq.m_u4BuildNum < FT_REQUIRED_META_DLL_BUILD_NUM) g_b_ver_Incorrect = KAL_TRUE; } } // assign the target version information p_dt->m_u4TargetMainVersion = FT_REQUIRED_META_DLL_MAIN_VER; p_dt->m_u4TargetMinorVersion = FT_REQUIRED_META_DLL_MINOR_VER; p_dt->m_u4TargetBuildNum = FT_REQUIRED_META_DLL_BUILD_NUM; } else // other type version check // so far, none, just assign version info to 0xFFFFFFFF { // in this case: version check pass p_dt->m_u4TargetMainVersion = FT_REQUIRED_VERSION_UNKNOWN; p_dt->m_u4TargetMinorVersion = FT_REQUIRED_VERSION_UNKNOWN; p_dt->m_u4TargetBuildNum = FT_REQUIRED_VERSION_UNKNOWN; g_b_ver_Incorrect = KAL_FALSE; } if(g_b_ver_Incorrect == KAL_TRUE) // version check fail { p_dt->m_bCheckPass = KAL_FALSE; //g_b_ft_assert_check_enable = req->cmd.m_rCheckMetaVerReq.b_AssertWhenVerCheckFail; } else // g_b_ver_Incorrect = KAL_FALSE; --> version check pass! { p_dt->m_bCheckPass = KAL_TRUE; g_b_ft_assert_check_enable = KAL_FALSE; // version pass: so stop checking! } g_u1_msg_recv_times = 0; cnf->status = FT_CNF_OK; }
/******************************************************************************* * FUNCTION * FT_ReadFrom_NVRAM() * * DESCRIPTION * Handle the read request of FT to NVRAM * * CALLS * None * * PARAMETERS * * * RETURNS * None * * GLOBALS AFFECTED * None *******************************************************************************/ void FT_ReadFrom_NVRAM(ft_nvram_read_req_struct_T* req) { ilm_struct* ptr_ilm; nvram_read_req_struct *ptrMsg; #ifdef __NVRAM_SECRET_DATA__ kal_uint8 key[256]; // at most 256 bytes kal_int32 real_key_len; kal_uint8 input_data[4]; kal_uint8 output_data[4]; kal_uint8 i; RC4_CNXT cnxt; kal_uint32 err_code = 0xFE; kal_bool bPassCheck = KAL_FALSE; real_key_len = custom_nvram_get_database_key(key, sizeof(key)); kal_mem_set(output_data, 0x0, sizeof(output_data)); // make sure if the authenticaion pass if(req->ciphered_data_valid && real_key_len > 0 ) // the load need to be checked, and user send ciphered data { kal_mem_cpy(input_data, &(req->file_idx), 2); kal_mem_cpy(input_data+2, &(req->para), 2); // deciphered the input data che_rc4_set_key((RC4_CNXT *)&cnxt, (kal_uint32)real_key_len, (kal_uint8 *)key); che_rc4((RC4_CNXT *)&cnxt, input_data , 4, key, real_key_len, CHE_MODE_NULL, output_data); for(i=0; i<4; i++) { if(output_data[i] != req->ciphered_data[i]) { err_code = 0xFD; break; } } if(i == 4) bPassCheck = KAL_TRUE; } else // ciphered data invalid { if(real_key_len == 0 || g_b_ft_nvram_proc_locally == true) // no need to checked bPassCheck = KAL_TRUE; else // need check, but user doesn't send data err_code = 0xFB; } if(!bPassCheck) { // invoke: kal_uint16 pdu_length_new = 0; kal_uint8 *pdu_ptr_new; peer_buff_struct *peer_buff_new; nvram_read_cnf_struct cnf_result; cnf_result.file_idx = req->file_idx; cnf_result.para = req->para; cnf_result.result = err_code; // allocate a peer buffer to stored the output data for debug if( NULL != (peer_buff_new=construct_peer_buff(4, 0, 0, TD_CTRL)) ) { pdu_ptr_new = get_pdu_ptr( peer_buff_new, &pdu_length_new ); kal_mem_cpy(pdu_ptr_new, output_data , 4); peer_buff_new->pdu_len = 4; } FT_ReadFrom_NVRAM_CNF(&cnf_result, peer_buff_new); return; } #endif // #ifdef __NVRAM_SECRET_DATA__ ptr_ilm = FT_ALLOC_OTHER_MSG( sizeof(nvram_read_req_struct) ); /* if ptrMsg != NULL*/ ptrMsg = (nvram_read_req_struct *)ptr_ilm->local_para_ptr; ptrMsg->file_idx=req->file_idx; ptrMsg->access_id=0; ptrMsg->para=req->para; /* FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) */ FT_SEND_MSG(MOD_FT, MOD_NVRAM, PS_NVRAM_SAP, MSG_ID_NVRAM_READ_REQ, ptr_ilm);// wait READ_CNF }
void FT_WriteTo_NVRAM(ft_nvram_write_req_struct_T* req, peer_buff_struct* peer_buff, ilm_struct* ptrMsg) { ilm_struct *ptr_ilm; nvram_write_req_struct *nvram_ptr_loc_para; kal_uint16 pdu_length; kal_uint8 *pdu_ptr = get_pdu_ptr( peer_buff, &pdu_length ); #ifdef __NVRAM_SECRET_DATA__ kal_bool bPassCheck = KAL_FALSE; kal_int32 err_code = 0xFE; kal_uint8 key[256]; // at most 256 bytes kal_int32 real_key_len; real_key_len = custom_nvram_get_database_key(key, sizeof(key)); if(req->msg_num == 2 && real_key_len >0) // we must wait until we collect all { if(req->msg_idx == 0) // allocate a peer buffer to store it. { if(p_g_pbs_ft_nvram != NULL) // free previous buffer { free_peer_buff(p_g_pbs_ft_nvram); p_g_pbs_ft_nvram = NULL; } // allocate a new peer buffer if( NULL != (p_g_pbs_ft_nvram=construct_peer_buff(pdu_length, 0, 0, TD_CTRL)) ) { p_g_u1_ft_nvram_pdu_ptr = get_pdu_ptr( p_g_pbs_ft_nvram, &g_u2_ft_nvram_pdu_length ); kal_mem_cpy(p_g_u1_ft_nvram_pdu_ptr, pdu_ptr , pdu_length); p_g_pbs_ft_nvram->pdu_len = pdu_length; } return; // wait for next message } else // the second message with encrpted data { kal_int32 i; RC4_CNXT cnxt; kal_uint8 *output_data = (kal_uint8*) get_ctrl_buffer(g_u2_ft_nvram_pdu_length); // since at most 2k bytes if(p_g_u1_ft_nvram_pdu_ptr!=NULL) { // get the key //real_key_len = custom_nvram_get_database_key(key, sizeof(key)); if(real_key_len >0) // get the key { // deciphered the input data che_rc4_set_key((RC4_CNXT *)&cnxt, (kal_uint32)real_key_len, (kal_uint8 *)key); che_rc4((RC4_CNXT *)&cnxt, p_g_u1_ft_nvram_pdu_ptr , g_u2_ft_nvram_pdu_length, key, real_key_len, CHE_MODE_NULL, output_data); for(i=0; i<g_u2_ft_nvram_pdu_length; i++) { if(output_data[i] != pdu_ptr[i]) { err_code = 0xFD; break; } } if(i == g_u2_ft_nvram_pdu_length) { bPassCheck = true; } } } else { err_code = 0xFC; } free_ctrl_buffer(output_data); } } else { if(real_key_len == 0 || g_b_ft_nvram_proc_locally == true) // sec not ON bPassCheck = true; } if(!bPassCheck) { // invoke: nvram_write_cnf_struct cnf_result; cnf_result.file_idx = req->file_idx; cnf_result.para = req->para; cnf_result.result = err_code; // allocate a peer buffer to stored the output data for debug FT_WriteTo_NVRAM_CNF(&cnf_result); return; } if(real_key_len >0 && req->msg_num == 2 && p_g_pbs_ft_nvram != NULL) // re-assign the pdu_ptr, and free the buffer { kal_mem_cpy(pdu_ptr, p_g_u1_ft_nvram_pdu_ptr,pdu_length); free_peer_buff(p_g_pbs_ft_nvram); p_g_pbs_ft_nvram = NULL; } #endif // #ifdef __NVRAM_SECRET_DATA__ ptr_ilm = FT_ALLOC_OTHER_MSG( sizeof(nvram_write_req_struct) ); nvram_ptr_loc_para=(nvram_write_req_struct *)(ptr_ilm->local_para_ptr); nvram_ptr_loc_para->file_idx=req->file_idx;/* LID */ nvram_ptr_loc_para->para=req->para; nvram_ptr_loc_para->access_id=0 ; // change it! #ifdef _LOW_COST_SINGLE_BANK_FLASH_ { // stop RF L1TST_Stop(); } #endif // #ifdef _LOW_COST_SINGLE_BANK_FLASH_ // keep a runtime buffer of the written value for updating L1 runtime // FIX: ACCESS OUT-OF BOUND if(pdu_length > sizeof(ft_rf_data_pt)) { kal_mem_cpy(&ft_rf_data_pt, pdu_ptr, sizeof(ft_rf_data_pt)); } else { kal_mem_cpy(&ft_rf_data_pt, pdu_ptr, pdu_length); } ptr_ilm->peer_buff_ptr = peer_buff; /* FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) */ FT_SEND_MSG(MOD_FT, MOD_NVRAM, PS_NVRAM_SAP, MSG_ID_NVRAM_WRITE_REQ, ptr_ilm); if(ptrMsg != NULL) ptrMsg->peer_buff_ptr=NULL;/* make sure the NVRAM will release the mem*/ }