/***************************************************************************** * FUNCTION * l4c_nw_reg_state_mind * DESCRIPTION * * PARAMETERS * * RETURNS * void *****************************************************************************/ void l4c_nw_reg_state_mind(kal_uint8 gsm_state, kal_uint8 gprs_state, kal_uint32 cause) { kal_uint16 infBuffSize = 0; kal_uint8 *infBuff = NULL; mbci_context_struct *mbci_ptr = MBCI_PTR; mbci_ptr->NwError = cause; if (MBCI_PTR->state != MBCI_STATE_OPEN) { return; } // CS registration state if (mbci_ptr->gsm_state != gsm_state) { infBuff = (kal_uint8*)get_ctrl_buffer(sizeof(mbim_registration_state_info_struct) + 64); // 64 byte reserve for ProviderId and ProviderName infBuffSize = mbci_get_registration_state_info(MBCI_SRC, (kal_uint8*)infBuff); mbci_status_ind(MBIM_CID_REGISTER_STATE, MBIM_UUID_BASIC_CONNECT, infBuffSize, infBuff); free_ctrl_buffer(infBuff); } // PS packet service state if (mbci_ptr->gprs_state != gprs_state) { infBuff = (kal_uint8*)get_ctrl_buffer(sizeof(mbim_packet_service_info_struct)); infBuffSize = mbci_get_packet_service_info(MBCI_SRC, (kal_uint8*)infBuff); mbci_status_ind(MBIM_CID_PACKET_SERVICE, MBIM_UUID_BASIC_CONNECT, infBuffSize, infBuff); free_ctrl_buffer(infBuff); } mbci_ptr->gsm_state = gsm_state; mbci_ptr->gprs_state = gprs_state; }
S32 btmtk_goep_fs_findend(void *ptr) { bt_ftp_find_struct *pfind; pfind = (bt_ftp_find_struct *) ptr; #if defined(BTMTK_ON_WISE) if( NULL != pfind ) { FS_FindClose( (FS_HANDLE) pfind->hFile); pfind->hFile = 0; free_ctrl_buffer( pfind ); } #endif #ifdef BTMTK_GOEP_USE_WIN32_FS _findclose(pfind->hFile); _wchdir( (const U16 *) g_oldcwd ); if( NULL != ptr ) free( ptr ); #endif #ifdef BTMTK_ON_LINUX closedir(g_opened_dir); #endif return EXT_FS_OK; }
/***************************************************************************** * FUNCTION * format_asking_string * DESCRIPTION * Add mid_name and "?" into string. * PARAMETERS * string_id [IN] String ID * RETURNS * *****************************************************************************/ static PU8 format_asking_string(U16 string_id) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ kal_int32 string_len = mmi_ucs2strlen(GetString(string_id)); kal_wchar *mid_name = get_running_mid_name(); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ if (mid_name == NULL) { mid_name = (kal_wchar*) GetString(STR_SCR_JAVA_CAPTION); } if (asking_string_buffer != NULL) { free_ctrl_buffer(asking_string_buffer); } asking_string_buffer = (kal_wchar*) get_ctrl_buffer((string_len + mmi_ucs2strlen((S8*) mid_name) + 2) << 1); mmi_ucs2cpy((S8*) asking_string_buffer, GetString(string_id)); mmi_ucs2cpy((S8*) (asking_string_buffer + string_len), (S8*) mid_name); string_len += mmi_ucs2strlen((S8*) mid_name); asking_string_buffer[string_len] = '?'; asking_string_buffer[string_len + 1] = 0; return (PU8) asking_string_buffer; }
/** * Get Path for requested size */ kal_int16 FT_GetAvailableDrive(kal_int32 size) { #if !defined(__LOW_COST_SUPPORT_ULC__) kal_int16 drv_letter = -1; kal_int16 i = 0; kal_uint32 dev[4] = {FS_DRIVE_I_SYSTEM, FS_DRIVE_V_NORMAL, FS_DRIVE_V_REMOVABLE, FS_DRIVE_V_EXTERNAL}; kal_wchar *pathname = NULL; pathname = (kal_wchar*)get_ctrl_buffer(FT_FAT_MAX_FULLPATH); if(pathname) { for(i=0;i<4;i++) { drv_letter = FS_GetDrive(dev[i], 1, FS_NO_ALT_DRIVE); if(drv_letter > 0) { kal_wsprintf(pathname, "%c:\\", drv_letter); if(size < FT_GetDiskFreeSpace(pathname)) { break; } } } } else { ASSERT(0); } free_ctrl_buffer(pathname); return drv_letter; #else // #if !defined(__LOW_COST_SUPPORT_ULC__) return -1; #endif // #if defined(__LOW_COST_SUPPORT_ULC__) }
/***************************************************************************** * FUNCTION * tcm_config_packets_trim * DESCRIPTION * This procedure trims config options. * * PARAMETERS * si_db_ptr IN Pointer to SIB * trim_after_nodes IN nodes * RETURNS * void * GLOBALS AFFECTED * N/A *****************************************************************************/ void tcm_config_packets_trim ( SESSION_INFO_PTR si_db_ptr, kal_uint8 trim_after_nodes ) { tcm_protocol_config_packet_struct *head_node_ptr = NULL; tcm_protocol_config_packet_struct *node_to_delete_ptr = NULL; tcm_protocol_config_packet_struct *first_node = NULL; kal_uint8 nodes_count = 1; head_node_ptr = &si_db_ptr->prot_options_struct; while (nodes_count < trim_after_nodes) { nodes_count = nodes_count + 1; head_node_ptr = head_node_ptr->next_ptr; } /* Add 03.08.05 for memory leak */ first_node = head_node_ptr; head_node_ptr = head_node_ptr->next_ptr; while ( head_node_ptr != NULL ) { node_to_delete_ptr = head_node_ptr; head_node_ptr = head_node_ptr->next_ptr; // kal_prompt_trace(MOD_TCM, "tcm_config_packets_trim free: %x", node_to_delete_ptr);// Carlson temp add, can remove this free_ctrl_buffer(node_to_delete_ptr); } first_node->next_ptr = NULL; return; }
kal_int32 init_gt818_download_module( kal_uint16 cur_ver, kal_uint8 *firmware_ptr ) { kal_int32 ret = 0; outbuf = (kal_uint8 *)get_ctrl_buffer( MAX_BUFFER_LEN ); inbuf = (kal_uint8 *)get_ctrl_buffer( MAX_BUFFER_LEN ); dbgbuf = (kal_char *)get_ctrl_buffer( MAX_BUFFER_LEN ); if ( ( outbuf == NULL ) || ( inbuf == NULL ) || ( dbgbuf == NULL ) ) { EXT_ASSERT(0, (kal_uint32)outbuf, (kal_uint32)inbuf, (kal_uint32)dbgbuf); return 0; } CTP_DWN_DEBUG_LINE_TRACE(); //rst_handle = DclGPIO_Open(DCL_GPIO, GPIO_CTP_SHUTDN_PIN); //int_handle = DclGPIO_Open(DCL_GPIO, GPIO_CTP_INT_PIN); int_handle = DclGPIO_Open(DCL_GPIO, gpio_ctp_eint_pin); rst_handle = DclGPIO_Open(DCL_GPIO, gpio_ctp_reset_pin); DclGPIO_Control(rst_handle, GPIO_CMD_SET_MODE_0, NULL); DclGPIO_Control(int_handle, GPIO_CMD_SET_MODE_0, NULL); DclGPIO_Control(int_handle, GPIO_CMD_SET_DIR_OUT, NULL); ret = gt818_downloader_probe( cur_ver, firmware_ptr ); //DclGPIO_Control(int_handle, GPIO_CMD_SET_DIR_IN, NULL); //DclGPIO_Control(int_handle, GPIO_CMD_SET_MODE_1, NULL); DclGPIO_Control(int_handle, GPIO_CMD_WRITE_HIGH, NULL); DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_HIGH, NULL); kal_sleep_task(5); DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_LOW, NULL); kal_sleep_task(5); DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_HIGH, NULL); kal_sleep_task(120); free_ctrl_buffer( outbuf ); free_ctrl_buffer( inbuf ); free_ctrl_buffer( dbgbuf ); if ( downloader_errno ) EXT_ASSERT( 0, downloader_errno, 0, 0 ); return ret; }
/***************************************************************************** * FUNCTION * tp_ps_handling_at_indication * DESCRIPTION * This function is used to handle the response/URC data from MOD_ATCI * * PARAMETERS * channelId [IN] * buf [IN] * iDataLen [IN] * * RETURNS * void *****************************************************************************/ static void tp_ps_handling_at_indication(kal_uint8 channelId, kal_char *buf, kal_uint16 iDataLen) { kal_char *data; if (tp_callback == NULL || tp_port_begin == -1) { if (tp_callback == NULL) { kal_prompt_trace( stack_get_active_module_id(), "[Hdlr] ERROR: havn't register TP callback function"); } else if (tp_port_begin == -1) { kal_prompt_trace( stack_get_active_module_id(), "[Hdlr] ERROR: havn't start PS, please call tp_ps_start first"); } // buffer the URC if (channelId == RMMI_MSG_BASED_URC_CHANNEL) { kal_prompt_trace( stack_get_active_module_id(), "[Hdlr] Buffer the URC: %s", buf); if ( (tp_urc_buffer_len + iDataLen) > MAX_TP_URC_BUFFER_LENGTH) { kal_prompt_trace( stack_get_active_module_id(), "[Hdlr] URC buffer is full, clean the buffer", buf); tp_urc_buffer_len = 0; } if (iDataLen > MAX_TP_URC_BUFFER_LENGTH) { kal_prompt_trace( stack_get_active_module_id(), "[Hdlr] ERROR: the URC is too large, please increase the URC buffer"); } else { kal_mem_cpy(tp_urc_buffer+tp_urc_buffer_len, buf, iDataLen); tp_urc_buffer_len += iDataLen; } } } else { data = get_ctrl_buffer(iDataLen); kal_mem_cpy(data, buf, iDataLen); tp_callback(channelId, data, iDataLen, 1); free_ctrl_buffer(data); } }
/***************************************************************************** * FUNCTION * jpush_alarm_del * DESCRIPTION * Delete one entry from the alarm registry. * If the entry can not be found, return -1. * On succesful deletion, write a new copy of the file to disk. * PARAMETERS * del_alarm [?] * RETURNS * *****************************************************************************/ kal_int32 jpush_alarm_del(alarmentry_struct *del_alarm) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ alarmentry_struct *alarmp = g_jpush_alarmlist_ptr; alarmentry_struct *lastp; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ /* Check if the entry already exists? */ kal_trace(TRACE_FUNC, JPUSH_ALARM_DEL); jpush_timer_mutex_lock(); for (lastp = alarmp; alarmp != NULL; alarmp = alarmp->next) { if (del_alarm == alarmp) { /* Remove an entry. */ if (alarmp == g_jpush_alarmlist_ptr) { g_jpush_alarmlist_ptr = alarmp->next; } else { lastp->next = alarmp->next; } alarmp->next = NULL; free_ctrl_buffer(alarmp->midlet); alarmp->midlet = NULL; free_ctrl_buffer(alarmp->storagename); alarmp->storagename = NULL; alarmp->event_id = NULL; free_ctrl_buffer(alarmp); jpush_alarm_save(); jpush_timer_mutex_unlock(); return (0); } lastp = alarmp; } jpush_timer_mutex_unlock(); return (-1); }
static Media_Status GenCompRecClose( MHdl *hdl ) { MHPB_Internal *ihdl = (MHPB_Internal *)hdl; kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_CLOSE, hdl->mediaType, hdl, hdl->state,0,0,0,0,0); ASSERT( hdl != 0 ); if (hdl->state == COMPONENT_STATE_PLAY) { hdl->Stop(hdl); } // Deinit component { AcHdlNode *pNode = ihdl->pNodeStart; while (pNode) { pNode->curHdl->Deinit( pNode->curHdl ); if (pNode->pAllocBuf) { audio_free_mem( (void **) &pNode->pAllocBuf); } pNode = pNode->pNextNode; } } // Wav only if (ihdl->pPublicInfo) { free_ctrl_buffer( ihdl->pPublicInfo ); } // Free memory if (ihdl->pAllocBuf) { if (ihdl->fIspAllocBufOnMED) { audio_free_mem( (void **) &ihdl->pAllocBuf); } else { free_ctrl_buffer(ihdl->pAllocBuf); ihdl->pAllocBuf = NULL; } } mhdlFinalize(hdl, NULL); free_ctrl_buffer( hdl ); return MEDIA_SUCCESS; }
void SP_Strm_Disable( void ) { #if !defined(SS_UNIT_TEST) UART_CTRL_CLOSE_T data; data.u4OwenrId = MOD_MED; DclSerialPort_Control( intSStrmControl->cmux_handle, SIO_CMD_CLOSE, (DCL_CTRL_DATA_T*)&data); #endif free_ctrl_buffer(intSStrmControl); intSStrmControl = NULL; L1SP_UnRegister_Strm_Handler(); }
/***************************************************************************** * FUNCTION * jpush_alarm_free * DESCRIPTION * * PARAMETERS * void * RETURNS * void *****************************************************************************/ void jpush_alarm_free() { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ alarmentry_struct *alarmp, *alarmtmp; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ /* clean up the list */ jpush_timer_mutex_lock(); for (alarmp = g_jpush_alarmlist_ptr; alarmp != NULL; alarmp = alarmtmp) { alarmtmp = alarmp->next; free_ctrl_buffer(alarmp->midlet); free_ctrl_buffer(alarmp->storagename); free_ctrl_buffer(alarmp); } jpush_timer_mutex_unlock(); }
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; }
/***************************************************************************** * FUNCTION * _aud_trim_close * DESCRIPTION * This function is to release all the allocated resources for the opened * trim handler. * PARAMETERS * void * RETURNS * void *****************************************************************************/ static void _aud_trim_close(void) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ Media_Status drv_result; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ /* Directly return if the trim handle is not opened */ if (!g_is_trim_opened) { return; } /* Close MHdl handler */ if (g_trim_ctx.mhdl_handle_p) { /* Close MHdl handler */ drv_result = g_trim_ctx.mhdl_handle_p->Close(g_trim_ctx.mhdl_handle_p); _AUD_TRIM_TRACE(drv_result, g_trim_ctx.mhdl_handle_p, -1); g_trim_ctx.mhdl_handle_p = NULL; } /* Free FSAL resources */ if (g_trim_ctx.is_fsal_opened) { /* Free buffer */ if (g_trim_ctx.fsal_handle.bBuffering && g_trim_ctx.fsal_handle.pbBuf != NULL) { free_ctrl_buffer(g_trim_ctx.fsal_handle.pbBuf); } /* Close FSAL handler */ FSAL_Close(&g_trim_ctx.fsal_handle); g_trim_ctx.is_fsal_opened = KAL_FALSE; } /* Close file output handle */ if (g_trim_ctx.file_output >= 0) { FS_Close(g_trim_ctx.file_output); g_trim_ctx.file_output = -1; } g_is_trim_opened = KAL_FALSE; }
void BleServiceDbUnloadRecord(void) { if (BleDbCtx(loadCount) == 1) { BT_GattUnregisterConnectedEvent(&BleDbCtx(gattHandler)); ATTDB_UnRegisterBondStatus(&BleDbCtx(bondingHandler)); while (!IsListEmpty(&BleDbCtx(servicedbList))) { free_ctrl_buffer(RemoveHeadList(&BleDbCtx(servicedbList))); } } BleDbCtx(loadCount)--; }
/***************************************************************************** * FUNCTION * l4c_sms_new_msg_pdu_mind * DESCRIPTION * * PARAMETERS * * RETURNS * void *****************************************************************************/ void l4c_sms_new_msg_pdu_mind(kal_uint8 mti, void *data, kal_uint16 packed_peer_buff_len) { if (MBCI_PTR->state != MBCI_STATE_OPEN) { return; } if (mti == SMSAL_MTI_DELIVER) { kal_uint16 infBuffSize = 0; kal_uint8 *infBuff = NULL; mbim_sms_read_info_struct ind; MBIM_OL_PAIR_LIST SmsRefList; mbim_sms_pdu_record_struct pdu; infBuffSize = sizeof(ind) + sizeof(SmsRefList) + sizeof(pdu); infBuff = (kal_uint8*)get_ctrl_buffer(infBuffSize); ind.Format = MBIMSmsFormatPdu; ind.ElementCount = 1; SmsRefList.offset = sizeof(ind); SmsRefList.size = sizeof(pdu); pdu.MessageIndex = MBIM_MESSAGE_INDEX_NONE; pdu.MessageStatus = MBIMSmsStatusNew; pdu.PduDataOffset = 16; if (packed_peer_buff_len <= 183) { pdu.PduDataSize = packed_peer_buff_len; } else { DEBUG_ASSERT(0); pdu.PduDataSize = 183; } kal_mem_cpy((void*)pdu.DataBuffer, data, pdu.PduDataSize); // Copy to infBuff mbci_infBuff_cpy(infBuff, 0, sizeof(ind), (void*)&ind); mbci_infBuff_cpy(infBuff, sizeof(ind), sizeof(SmsRefList), (void*)&SmsRefList); mbci_infBuff_cpy(infBuff, sizeof(ind) + sizeof(SmsRefList), sizeof(pdu), (void*)&pdu); mbci_status_ind(MBIM_CID_SMS_READ, MBIM_UUID_SMS, infBuffSize, infBuff); free_ctrl_buffer(infBuff); } }
//=============== local buffer process ========================= void ft_misc_cal_data_free_alloc_buf(void) { if(p_ft_misc_buf) // free the buffer { if(b_ft_misc_buf_from_med) // free the buffer we borrow from MED task { FtFreeExtMemory(p_ft_misc_buf); } else // free the control buffer { free_ctrl_buffer(p_ft_misc_buf); } p_ft_misc_buf = NULL; } }
static Media_Status GenCompClose( MHdl *hdl ) { MHPB_Internal *ihdl = (MHPB_Internal *)hdl; kal_int32 I; kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_CLOSE, hdl->mediaType, hdl, hdl->state,0,0,0,0,0); ASSERT( hdl != 0 ); if(hdl->state == COMPONENT_STATE_PLAY) { hdl->Stop(hdl); } // Deinit component for (I=ihdl->numComp-1; I>=0; I--) { ihdl->NodeArray[I].curHdl->Deinit(ihdl->NodeArray[I].curHdl); } // Wav only if (ihdl->pPublicInfo) { free_ctrl_buffer( ihdl->pPublicInfo ); } // Free memory if (ihdl->pAllocBuf) { if (ihdl->fIspAllocBufOnMED) { audio_free_mem( (void **) &ihdl->pAllocBuf); } else { free_ctrl_buffer(ihdl->pAllocBuf); ihdl->pAllocBuf = NULL; } } mhdlFinalize(hdl, NULL); free_ctrl_buffer( hdl ); return MEDIA_SUCCESS; }
extern void asnMemFree(void ** ppBuffer) { /** * For MCDDLL, malloc() from C Standard Library is used; * otherwise, memory allocation from KAL is used. */ if(NULL == *ppBuffer) return; #ifdef MCD_DLL_EXPORT free(*ppBuffer); #else free_ctrl_buffer(*ppBuffer); #endif *ppBuffer = NULL; }
/***************************************************************************** * FUNCTION * free_asking_string * DESCRIPTION * Free the memory of asking string * PARAMETERS * void * RETURNS * void *****************************************************************************/ static void free_asking_string(void) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ if (asking_string_buffer != NULL) { free_ctrl_buffer(asking_string_buffer); } asking_string_buffer = NULL; }
/***************************************************************************** * FUNCTION * l4c_sim_status_update_mind * DESCRIPTION * * PARAMETERS * * RETURNS * void *****************************************************************************/ void l4c_sim_status_update_mind() { kal_uint16 infBuffSize; kal_uint8 *infBuff = NULL; if (MBCI_PTR->state != MBCI_STATE_OPEN) { return; } infBuff = (kal_uint8*)get_ctrl_buffer(sizeof(mbim_subscriber_ready_info_struct) + sizeof(mbim_subscriber_ready_info_databuffer_struct)); infBuffSize = mbci_get_subscriber_ready_info(MBCI_SRC, infBuff, sizeof(mbim_subscriber_ready_info_struct) + sizeof(mbim_subscriber_ready_info_databuffer_struct)); mbci_status_ind(MBIM_CID_SUBSCRIBER_READY_STATUS, MBIM_UUID_BASIC_CONNECT, infBuffSize, infBuff); free_ctrl_buffer(infBuff); }
void BleServiceDbUpdateRecord(ble_service_db *servicedb) { S32 fd; S32 pos_current; S32 pos_end; U32 mode = BTMTK_FS_READ_WRITE; U8 *db_buff; if (!btmtk_fs_is_dir_exist((const U8*)BLE_SERVICE_DATABASE_FILE)) { mode |= BTMTK_FS_CREATE; } fd = btmtk_fs_open((const U8*)BLE_SERVICE_DATABASE_FILE, mode); if (fd < 0) { return; } pos_end = btmtk_fs_seek(fd, 0, BTMTK_FS_SEEK_END); pos_current = btmtk_fs_seek(fd, 0, BTMTK_FS_SEEK_BEGIN); db_buff = (U8 *)get_ctrl_buffer(sizeof(ble_service_db) - sizeof(ListEntry)); while (pos_current < pos_end) { btmtk_fs_read(fd, db_buff, sizeof(ble_service_db) - sizeof(ListEntry)); if (OS_MemCmp(db_buff, 6, servicedb->bdAddr.addr, 6)) { btmtk_fs_seek(fd, pos_current, BTMTK_FS_SEEK_BEGIN); break; } pos_current += (sizeof(ble_service_db) - sizeof(ListEntry)); } free_ctrl_buffer(db_buff); Report(("[BleDB] Update record in file, seek offset: %d", pos_current)); // kal_trace(BT_TRACE_BLE_PROFILES, BLEDB_UPDATERECORD_OFFSET, pos_current); btmtk_fs_write(fd, ((U8 *)servicedb) + sizeof(ListEntry), sizeof(ble_service_db) - sizeof(ListEntry)); btmtk_fs_close(fd); }
static Media_Status pcmStrmMFClose( MHdl *hdl ) { pcmStrmMediaHdl *ihdl = (pcmStrmMediaHdl *)hdl; if (ihdl->pcmStrm.isPlayback) { ASSERT( hdl != 0 && hdl->state != WAV_STATE_PLAYING); mhdlFinalize( hdl, 0 ); } else { ASSERT( hdl != 0 && hdl->state != WAV_STATE_RECORDING); mhdlFinalize( hdl, 0 ); } L1SP_PCMPlayback_ClearFlag(); free_ctrl_buffer( hdl ); kal_trace( TRACE_FUNC, L1AUDIO_CLOSE, MEDIA_FORMAT_PCM_8K ); return MEDIA_SUCCESS; }
/***************************************************************************** * FUNCTION * custom_nvram_get_database_key * DESCRIPTION * to get the custom database key * PARAMETERS * key_buffer [OUT] the output buffer to save key * buffer_size [IN] the size of key buffer * RETURNS * 0: Fail * n: the lenghth of database key *****************************************************************************/ kal_int32 custom_nvram_get_database_key(kal_uint8 *key_buffer, kal_uint32 buffer_size) { #ifdef __NVRAM_SECRET_DATA__ /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ CUST_SECRET_DATA_ST* tmp_buffer; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ if (buffer_size < NVRAM_DATABASE_KEY_SIZE) { return 0; } buffer_size = sizeof(custom_secret_data); tmp_buffer = (CUST_SECRET_DATA_ST*) get_ctrl_buffer(buffer_size); #ifdef __MTK_TARGET__ if (SST_Get_NVRAM_Key((kal_uint32*)&custom_secret_data, (kal_uint32*) tmp_buffer, &buffer_size)) { memcpy(key_buffer, tmp_buffer->m_custom_database_key, NVRAM_DATABASE_KEY_SIZE); buffer_size = NVRAM_DATABASE_KEY_SIZE; } else { buffer_size = 0; } #else memcpy(key_buffer, custom_secret_data.m_custom_database_key, NVRAM_DATABASE_KEY_SIZE); #endif /* __MTK_TARGET__ */ free_ctrl_buffer((kal_uint8*)tmp_buffer); return buffer_size; #else return 0; #endif }
/***************************************************************************** * FUNCTION * nvram_send_ilm * DESCRIPTION * This is nvram_send_ilm function of NVRAM module. * PARAMETERS * dest_id [IN] * msg_id [IN] * local_param_ptr [?] * peer_buf_ptr [?] * ilm_ptr(?) [IN] The primitives * RETURNS * void *****************************************************************************/ void nvram_send_ilm(module_type dest_id, msg_type msg_id, void *local_param_ptr, void *peer_buf_ptr) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ ilm_struct *ilm_ptr = NULL; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ if (dest_id == MOD_RTC_HISR || dest_id == MOD_SIM) { if (local_param_ptr) free_ctrl_buffer(local_param_ptr); if (peer_buf_ptr) free_peer_buff(peer_buf_ptr); return; } ilm_ptr = allocate_ilm(MOD_NVRAM); ASSERT(ilm_ptr != NULL); ilm_ptr->src_mod_id = MOD_NVRAM; ilm_ptr->msg_id = msg_id; ilm_ptr->local_para_ptr = (local_para_struct*) local_param_ptr; ilm_ptr->peer_buff_ptr = (peer_buff_struct*) peer_buf_ptr; ilm_ptr->dest_mod_id = dest_id; ilm_ptr->sap_id = PS_NVRAM_SAP; /** * Sigh, since SEND_ILM is a macro uses ## directive, * the formal parameter of dest_mod_id must be hardcoded. * So NVRAM DOES NOT use it. >=P */ msg_send_ext_queue(ilm_ptr); } /* End of nvram_send_ilm */
Media_Status wavRecordAppendable( Media_Format format, FS_HANDLE fs, Media_Record_File_Info *info ) { uint8 *pBuf; Media_Status status; uint32 len; // To initialize info memset(info, 0, sizeof(Media_Record_File_Info)); // Get the file size if (FS_NO_ERROR != FS_GetFileSize(fs, &info->fileSize) ) return MEDIA_READ_FAIL; // To get the enough wav header which is supported by MediaTek pBuf = (uint8*)get_ctrl_buffer( 60*sizeof(uint8) ); memset(pBuf, 0, 60*sizeof(uint8)); if ( FS_NO_ERROR != FS_Read(fs, pBuf, 60, &len) ) { status = MEDIA_READ_FAIL; } else { // Parse the wav header status = wavParseRecordFile(pBuf, len, info); } free_ctrl_buffer( pBuf ); // Compare the file information and wav format if (status == MEDIA_SUCCESS) { // Type mismatch if (format != info->format) return MEDIA_FAIL; } return status; }
static kal_bool process_gt818_ctp_cmd( kal_uint8 action, kal_uint32 data_len, kal_uint8 *data_str ) { kal_uint16 ret_len = 0; kal_uint16 i; kal_uint16 inlen; kal_uint16 offset; STS_CTRL_COMMAND_T cmd; DCL_HANDLE handle; kal_uint8 *ctp_buffer = NULL; kal_uint8 *result = NULL; ctp_buffer = (kal_uint8 *)get_ctrl_buffer( 1024 ); if ( ctp_buffer == NULL ) EXT_ASSERT(0, (int)ctp_buffer, 0, 0); cmd.u4Command = action; cmd.pVoid1 = (void *)data_str; cmd.pVoid2 = (void *)&result; handle = DclSTS_Open( DCL_TS, 0 ); DclSTS_Control( handle, STS_CMD_COMMAND, (DCL_CTRL_DATA_T *)&cmd ); DclSTS_Close(handle); if ( action == DCL_CTP_COMMAND_GET_VERSION ) ret_len = 6; if ( action == DCL_CTP_COMMAND_GET_CONFIG ) ret_len = 106; if ( action == DCL_CTP_COMMAND_GET_DIFF_DATA ) ret_len = 162; if ( action == DCL_CTP_COMMAND_GET_FW_BUFFER ) { offset = data_str[0]*256 + data_str[1]; inlen = data_str[2]; memcpy( &result[offset], &data_str[3], inlen); if ( inlen != 128 ) { #define GT818_FW_STRING "ctp_firmware_rusklmeoxkwjadfjnklruo3" kal_int16 drv_letter; FS_HANDLE fs_handle; UINT writen; kal_wchar CTP_FIRMWARE_PATH[64]; drv_letter = FS_GetDrive(FS_DRIVE_V_NORMAL, 2, FS_DRIVE_I_SYSTEM | FS_DRIVE_V_NORMAL); kal_wsprintf( CTP_FIRMWARE_PATH, "%c:\\%s", drv_letter, GT818_FW_STRING ); fs_handle = FS_Open( CTP_FIRMWARE_PATH, FS_CREATE_ALWAYS | FS_READ_WRITE ); FS_Write(fs_handle, (kal_uint8 *) result , offset+inlen, &writen); FS_Close( fs_handle ); } } kal_sprintf( (kal_char *)ctp_buffer, "+EGCMD: " ); for ( i = 0 ; i < ret_len ; i++ ) kal_sprintf( (kal_char *)&ctp_buffer[strlen((char *)(ctp_buffer))], "%02X", result[i] ); rmmi_write_unsolicitedResultCode( ctp_buffer, strlen((kal_char *)(ctp_buffer)), KAL_TRUE, 1, NULL ); free_ctrl_buffer( ctp_buffer ); return KAL_TRUE; }
/***************************************************************************** * FUNCTION * phb_search_confirm * DESCRIPTION * This is phb_search_confirm function of PHB module. * PARAMETERS * result [IN] * actual_count [IN] * src_id [IN] * cnf_msg_id [IN] * control_block [?] * ilm_ptr(?) [IN] The primitives * RETURNS * void *****************************************************************************/ static void phb_search_confirm( phb_errno_enum result, kal_uint16 actual_count, kal_uint8 src_id, msg_type cnf_msg_id, control_block_type *control_block) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ local_para_struct *local_param_ptr = NULL; peer_buff_struct *peer_buf_ptr = NULL; kal_uint16 msg_id = 0; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ kal_trace(TRACE_FUNC, FUNC_PHB_SEARCH_CNF, result, actual_count, src_id, cnf_msg_id); /* First we release local parameter. */ if ((result != PHB_ERRNO_BUSY) && (control_block->local_param_ptr != NULL)) { free_ctrl_buffer(control_block->local_param_ptr); } if ((result == PHB_ERRNO_BUSY) || (control_block->cnf_msg_id == MSG_ID_L4CPHB_SEARCH_REQ)) { l4cphb_search_cnf_struct *l4cphb_search_cnf; l4cphb_search_cnf = (l4cphb_search_cnf_struct*) construct_local_para( sizeof(l4cphb_search_cnf_struct), TD_CTRL); l4cphb_search_cnf->total = actual_count; l4cphb_search_cnf->src_id = src_id; l4cphb_search_cnf->result = result; /* Field `cause' is meaningful when I/O occured by using control blocks */ l4cphb_search_cnf->cause = control_block->cause; if (result == PHB_ERRNO_BUSY) { phb_send_ilm(MOD_L4C, MSG_ID_L4CPHB_SEARCH_CNF, (local_para_struct*) l4cphb_search_cnf, NULL); return; } local_param_ptr = (local_para_struct*) l4cphb_search_cnf; msg_id = MSG_ID_L4CPHB_SEARCH_CNF; } /** * Under ADN mode, only when is_retrieve is true and searching into * physical storage device is required will call search_continue(), which * in consequence results in this search_confirm() is invoked. * * Since it is ADN mode, no matter the search result is, * the approval result is ALWAYS success!! */ else if (control_block->cnf_msg_id == MSG_ID_L4CPHB_APPROVE_REQ) { l4cphb_approve_cnf_struct *l4cphb_approve_cnf; l4cphb_approve_cnf = (l4cphb_approve_cnf_struct*) construct_local_para( sizeof(l4cphb_approve_cnf_struct), TD_CTRL); l4cphb_approve_cnf->result = PHB_ERRNO_SUCCESS; /* Field `cause' is meaningful when I/O occured by using control blocks */ l4cphb_approve_cnf->cause = control_block->cause; l4cphb_approve_cnf->type = control_block->type; l4cphb_approve_cnf->src_id = control_block->src_id; local_param_ptr = (local_para_struct*) l4cphb_approve_cnf; msg_id = MSG_ID_L4CPHB_APPROVE_CNF; } /* EXCEPTION cannot reach here */ if (control_block->peer_buf_ptr != NULL) { if (control_block->actual_count > 0) { peer_buf_ptr = (peer_buff_struct*) control_block->peer_buf_ptr; control_block->peer_buf_ptr = NULL; } else { free_ctrl_buffer(control_block->peer_buf_ptr); peer_buf_ptr = NULL; } control_block->need_free_peer = KAL_FALSE; } phb_free_control_block(control_block); phb_send_ilm(MOD_L4C, msg_id, local_param_ptr, peer_buf_ptr); } /* end of phb_search_confirm */
/***************************************************************************** * FUNCTION * aud_media_get_audio_format_in_video * DESCRIPTION * This function is to get the audio format in video * PARAMETERS * * RETURNS * kal_uint8 result *****************************************************************************/ kal_uint8 aud_stretch_is_aduio_in_video_PP_support(kal_wchar *file_name, kal_uint8 *data, kal_uint32 data_len, kal_int16 data_format) { #if defined(MED_PURE_AUDIO) /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ MP4_Parser_Status eMp4ParserRet; FSAL_Status eFSALRet; kal_uint8 result; kal_bool is_file_opened = KAL_FALSE; kal_bool has_aud_track; kal_bool is_PP_support = KAL_FALSE; Media_Format audio_format; kal_uint32 filesize; kal_uint32 index; kal_uint64 temp; STFSAL stFSAL_ROM; kal_uint8 *fsal_rom_buf; STMp4Parser *stMp4Parser_aud; STFSAL *stFSAL_aud; STFSAL *stFSAL_aud_stsz; STFSAL *stFSAL_aud_stco; STFSAL *stFSAL_aud_aud_data; kal_uint32 *mp4_aud_buf; kal_uint32 *mp4_aud_data_buf; kal_uint32 *mp4_aud_stco_buf; kal_uint32 *mp4_aud_stsz_buf; kal_uint32 *mp4_aud_stbl_buf; FS_FileLocationHint *aud_seek_hint; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ /* Open file for playing */ stFSAL_aud = (STFSAL*)get_ctrl_buffer(sizeof(STFSAL)); eFSALRet = FSAL_Open(stFSAL_aud, (void*)file_name, FSAL_READ); if (eFSALRet != FSAL_OK) { result = MED_RES_OPEN_FILE_FAIL; goto pure_audio_error_out; } is_file_opened = KAL_TRUE; /* Allocate working buffer for operation */ stMp4Parser_aud = (STMp4Parser*)get_ctrl_buffer(sizeof(STMp4Parser)); stFSAL_aud_stsz = (STFSAL*)get_ctrl_buffer(sizeof(STFSAL)); stFSAL_aud_stco = (STFSAL*)get_ctrl_buffer(sizeof(STFSAL)); stFSAL_aud_aud_data = (STFSAL*)get_ctrl_buffer(sizeof(STFSAL)); mp4_aud_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_FSAL_BUF_SIZE*sizeof(kal_uint32) ); mp4_aud_data_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_FSAL_BUF_SIZE*sizeof(kal_uint32) ); mp4_aud_stco_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_STCO_BUF_SIZE*sizeof(kal_uint32) ); mp4_aud_stsz_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_STSZ_BUF_SIZE*sizeof(kal_uint32) ); mp4_aud_stbl_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_STBL_BUF_SIZE*sizeof(kal_uint32) ); aud_seek_hint = (FS_FileLocationHint*)med_alloc_ext_mem( AUD_DEC_SEEK_HINT_SIZE*sizeof(FS_FileLocationHint) ); /* Set buffer for FSAL */ FSAL_SetBuffer(stFSAL_aud, AUD_MP4_FSAL_BUF_SIZE, (kal_uint8*)mp4_aud_buf); /* Set seek hint */ eFSALRet = FSAL_GetFileSize(stFSAL_aud, &filesize); if (eFSALRet != FSAL_OK) { result = MED_RES_OPEN_FILE_FAIL; goto pure_audio_error_out; } for (index = 0; index < AUD_DEC_SEEK_HINT_SIZE; index++) { temp = ((kal_uint64) filesize * (kal_uint64) (index + 1)) / (kal_uint64) (AUD_DEC_SEEK_HINT_SIZE + 1); aud_seek_hint[index].Index = (kal_uint32) temp; } DRM_set_seek_hint(stFSAL_aud->hFile, AUD_DEC_SEEK_HINT_SIZE, aud_seek_hint); /* Creat MP4 parser */ eMp4ParserRet = MP4_Parse(stMp4Parser_aud, stFSAL_aud); if (eMp4ParserRet != MP4_PARSER_OK && eMp4ParserRet != MP4_PARSER_WARNING_TRAILING_GARBAGE) { result = MED_RES_BAD_FORMAT; goto pure_audio_error_out; } /* Check if there's audio track */ MP4_MetaHasAudioTrack(stMp4Parser_aud, &has_aud_track); if (!has_aud_track) { result = MED_RES_MP4_NO_AUDIO_TRACK; goto pure_audio_error_out; } /* Prepare cache table */ eMp4ParserRet = MP4_STBL_CacheTablePreprocess( stMp4Parser_aud, mp4_aud_stbl_buf, AUD_MP4_STBL_BUF_SIZE); if (eMp4ParserRet != MP4_PARSER_OK) { result = MED_RES_BAD_FORMAT; goto pure_audio_error_out; } /* FSAL aud data */ eFSALRet = FSAL_Open_Attach(stFSAL_aud_aud_data, stFSAL_aud); if (eFSALRet != FSAL_OK) { result = MED_RES_OPEN_FILE_FAIL; goto pure_audio_error_out; } FSAL_SetBuffer(stFSAL_aud_aud_data, AUD_MP4_FSAL_BUF_SIZE, (kal_uint8*)mp4_aud_data_buf); /* FASL stco */ eFSALRet = FSAL_Open_Attach(stFSAL_aud_stco, stFSAL_aud); if (eFSALRet != FSAL_OK) { result = MED_RES_OPEN_FILE_FAIL; goto pure_audio_error_out; } FSAL_SetBuffer(stFSAL_aud_stco, AUD_MP4_STCO_BUF_SIZE, (kal_uint8*)mp4_aud_stco_buf); /* FSAL stsz */ eFSALRet = FSAL_Open_Attach(stFSAL_aud_stsz, stFSAL_aud); if (eFSALRet != FSAL_OK) { result = MED_RES_OPEN_FILE_FAIL; goto pure_audio_error_out; } FSAL_SetBuffer(stFSAL_aud_stsz, AUD_MP4_STSZ_BUF_SIZE, (kal_uint8*)mp4_aud_stsz_buf); /* Set FSAL to MP4 Parser */ MP4_Audio_SetFSAL(stMp4Parser_aud, stFSAL_aud_aud_data); MP4_SetFSAL_STCO(stMp4Parser_aud, MP4_TRACK_AUDIO, stFSAL_aud_stco); MP4_SetFSAL_STSZ(stMp4Parser_aud, MP4_TRACK_AUDIO, stFSAL_aud_stsz); MP4_UpdateSampleCount(stMp4Parser_aud, MP4_TRACK_AUDIO); /* Get Audio Type */ audio_format = MP4_Audio_Type_To_Media_Format(MP4_GetAudioType(stMp4Parser_aud)); AUD_VALUE_TRACE(audio_format, -1, __LINE__); /* The audio format in 3GP/MP4 file */ switch (audio_format) { /* Check AMR / AMR-WB by format enum directly */ #ifdef AMR_DECODE case MEDIA_FORMAT_AMR: #ifdef AMRWB_DECODE case MEDIA_FORMAT_AMR_WB: #endif is_PP_support = AudioPP_TS_IsSupport((Media_Format) audio_format, NULL); break; #endif /*AMR_DECODE*/ /* Need to wrap audio data in FSAL ROM file for check function */ #if defined(AAC_DECODE) case MEDIA_FORMAT_AAC: { kal_uint32 uSampleNo; kal_uint32 num_bytes; /* Seek to front and read a small range of data */ eMp4ParserRet = MP4_Audio_TimeToSampleNo(stMp4Parser_aud, 0, &uSampleNo ); if(eMp4ParserRet != MP4_PARSER_OK) { result = MED_RES_FAIL; goto pure_audio_error_out; } eMp4ParserRet = MP4_Audio_Seek(stMp4Parser_aud, uSampleNo); if(eMp4ParserRet != MP4_PARSER_OK) { result = MED_RES_FAIL; goto pure_audio_error_out; } /* Read audio data into buffer and set it to FSAL ROM file */ fsal_rom_buf = (kal_uint8*)med_alloc_ext_mem( AUD_STRETCH_FSAL_ROM_SIZE*sizeof(kal_uint8) ); eMp4ParserRet = MP4_Audio_Read(stMp4Parser_aud, fsal_rom_buf, AUD_STRETCH_FSAL_ROM_SIZE, &num_bytes); if((eMp4ParserRet != MP4_PARSER_OK) && (eMp4ParserRet != MP4_PARSER_READ_EOF)) { med_free_ext_mem((void**)&fsal_rom_buf); result = MED_RES_FAIL; goto pure_audio_error_out; } FSAL_Direct_SetRamFileSize(&stFSAL_ROM, num_bytes); eFSALRet = FSAL_Open(&stFSAL_ROM, (void*)fsal_rom_buf, FSAL_ROMFILE); if (eFSALRet != FSAL_OK) { med_free_ext_mem((void**)&fsal_rom_buf); result = MED_RES_OPEN_FILE_FAIL; goto pure_audio_error_out; } /* check time stretch support by using extract audio data in FSAL ROM file */ is_PP_support = AudioPP_TS_IsSupport((Media_Format) audio_format, &stFSAL_ROM); med_free_ext_mem((void**)&fsal_rom_buf); break; } #endif /*AAC_DECODE*/ default: result = MED_RES_INVALID_FORMAT; goto pure_audio_error_out; break; } if (is_PP_support) { result = MED_RES_OK; } else { result = MED_RES_UNSUPPORTED_SPEED; } pure_audio_error_out: if (is_file_opened) { FSAL_Close(stFSAL_aud); free_ctrl_buffer(stMp4Parser_aud); free_ctrl_buffer(stFSAL_aud_stsz); free_ctrl_buffer(stFSAL_aud_stco); free_ctrl_buffer(stFSAL_aud_aud_data); med_free_ext_mem((void**)&mp4_aud_buf); med_free_ext_mem((void**)&mp4_aud_data_buf); med_free_ext_mem((void**)&mp4_aud_stco_buf); med_free_ext_mem((void**)&mp4_aud_stsz_buf); med_free_ext_mem((void**)&mp4_aud_stbl_buf); med_free_ext_mem((void**)&aud_seek_hint); } free_ctrl_buffer(stFSAL_aud); return result; #else return MED_RES_INVALID_FORMAT; #endif /* #if defined(MED_PURE_AUDIO) */ }
U32 bpp_compose_vcard_to_xhtml(BTMTK_FS_HANDLE fh, U16* vcard_file) { btmtk_vcard_data_struct *p_vcard = NULL; S32 parse_rst; U8* cdata; int data_len, write_len; S32 ret; U32 total_len = 0; BT_BPP_FUNC_ENTRY(BPP_COMPOSE_VCARD2XHTML); /* Parsing */ p_vcard = get_ctrl_buffer(sizeof(btmtk_vcard_data_struct)); OS_MemSet((U8*)p_vcard, 0, sizeof(btmtk_vcard_data_struct)); parse_rst = btmtk_vcard_parse_file_to_struct(vcard_file, p_vcard); BT_BPP_TRACE_INFO_ARG1(BPP_PARSE_VCARD_FILE2STRUCT_RETURN, parse_rst); if (parse_rst != BTMTK_VCD_ERR_OK) { /* failed */ free_ctrl_buffer(p_vcard); return 0; } /* Composing */ /* 1. prologue */ cdata = bpp_get_xhtml_prologue(); data_len = strlen((char*)cdata); ret = bpp_fs_write(fh, cdata, data_len, &write_len); total_len += write_len; /* 2. head */ cdata = (U8* )vcard_xhtml_head_template; data_len = strlen((char*)cdata); ret = bpp_fs_write(fh, cdata, data_len, &write_len); total_len += write_len; /* 3. body start */ cdata = (U8* )vcard_xhtml_body_start; data_len = strlen((char*)cdata); ret = bpp_fs_write(fh, cdata, data_len, &write_len); total_len += write_len; /* 4. vCard attributes */ write_len = bpp_compose_vcard_attr_to_xhtml(fh, p_vcard); total_len += write_len; /* 5. body end */ cdata = (U8* )vcard_xhtml_body_end; data_len = strlen((char*)cdata); ret = bpp_fs_write(fh, cdata, data_len, &write_len); total_len += write_len; if (p_vcard) free_ctrl_buffer(p_vcard); return total_len; }
static U32 bpp_compose_vcard_attr_to_xhtml(BTMTK_FS_HANDLE fh, btmtk_vcard_data_struct *p_vcard) { U32 total_len = 0; //U32 data_len, write_len; int data_len, write_len; S8* pbuf = NULL; U8* pvalue = NULL; U8* pname = NULL; U8 field; int ret; #define BPP_TMP_BUF_LEN 512 pbuf = get_ctrl_buffer(BPP_TMP_BUF_LEN); for (field = 0; field < BPP_VCARD_FIELD_TOTAL; field++) { /* get value */ switch (field) { case BPP_VCARD_FIELD_NAME: { int fnlen, lnlen; fnlen = strlen((char*)p_vcard->first_name); lnlen = strlen((char*)p_vcard->second_name); if ((fnlen > 0) && (lnlen > 0)) { pname = get_ctrl_buffer(fnlen + lnlen + 2); strcpy((char*)pname, (char*)p_vcard->first_name); strcat((char*)pname, (char*)p_vcard->second_name); pvalue = pname; } else { pvalue = fnlen > 0 ? p_vcard->first_name : p_vcard->second_name; } /* compose */ sprintf(pbuf, vcard_xhtml_attr_template, bpp_vcard_field_str[field], pvalue); /* write to file */ data_len = strlen((char*)pbuf); ret = bpp_fs_write(fh, pbuf, data_len, &write_len); total_len += write_len; if (pname) { free_ctrl_buffer(pname); pname = NULL; } } /* get the next item */ continue; case BPP_VCARD_FIELD_TEL_CELL: pvalue = p_vcard->cell_num; break; case BPP_VCARD_FIELD_TEL_HOME: pvalue = p_vcard->home_num; break; case BPP_VCARD_FIELD_CMPNY: pvalue = p_vcard->company; break; case BPP_VCARD_FIELD_EMAIL: pvalue = p_vcard->email; break; case BPP_VCARD_FIELD_TEL_WORK: pvalue = p_vcard->office_num; break; case BPP_VCARD_FIELD_TEL_FAX: pvalue = p_vcard->fax_num; break; case BPP_VCARD_FIELD_BIRTHDAY: pvalue = p_vcard->birthday; break; case BPP_VCARD_FIELD_TITLE: pvalue = p_vcard->title; break; case BPP_VCARD_FIELD_URL: pvalue = p_vcard->url; break; case BPP_VCARD_FIELD_ADR_POBOX: pvalue = p_vcard->postbox; break; case BPP_VCARD_FIELD_ADR_EXTENSION: pvalue = p_vcard->extension; break; case BPP_VCARD_FIELD_ADR_STREET: pvalue = p_vcard->street; break; case BPP_VCARD_FIELD_ADR_CITY: pvalue = p_vcard->city; break; case BPP_VCARD_FIELD_ADR_STATE: pvalue = p_vcard->state; break; case BPP_VCARD_FIELD_ADR_POSTALCODE: pvalue = p_vcard->postcode; break; case BPP_VCARD_FIELD_ADR_COUNTRY: pvalue = p_vcard->country; break; case BPP_VCARD_FIELD_NOTE: pvalue = p_vcard->note; break; default: pvalue = NULL; break; } if (pvalue && (strlen((char*)pvalue) > 0)) { /* compose */ sprintf(pbuf, vcard_xhtml_attr_template, bpp_vcard_field_str[field], pvalue); /* write to file */ data_len = strlen((char*)pbuf); ret = bpp_fs_write(fh, pbuf, data_len, &write_len); total_len += write_len; } } if (pbuf) free_ctrl_buffer(pbuf); #undef BPP_TMP_BUF_LEN return total_len; }