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
* FT_ReadFrom_NVRAM_CNF
*
* DESCRIPTION
* Handle the confirmation of reading
*
* CALLS
*
*
* PARAMETERS
* local_para_struct * local_para_ptr, //( force to nvram_read_cnf_struct* cnf )
* peer_buff_struct * peer_buff_ptr
*
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*******************************************************************************/
void FT_ReadFrom_NVRAM_CNF(nvram_read_cnf_struct* cnf_result,
peer_buff_struct* peer_buff )
{
ilm_struct ilm_ptr;
ft_nvram_read_cnf_struct_T *ft_cnf;
if(!g_b_ft_nvram_proc_locally || cnf_result->file_idx != NVRAM_EF_CAL_DATA_CHECK_LID)
{
FT_ALLOC_MSG(&ilm_ptr, sizeof(ft_nvram_read_cnf_struct_T));
ft_cnf = (ft_nvram_read_cnf_struct_T *)ilm_ptr.local_para_ptr;
ft_cnf->header.ft_msg_id = FT_NVRAM_READ_CNF_ID;
ft_cnf->file_idx=cnf_result->file_idx;
ft_cnf->para=cnf_result->para;
#if defined(__MOD_NVRAM__)
if( nvram_test_lock() && (NVRAM_EF_SML_LID==cnf_result->file_idx) ) {
ft_cnf->status = 0xFF;
ilm_ptr.peer_buff_ptr = NULL;
free_peer_buff(peer_buff);
}
else
{
ft_cnf->status = cnf_result->result;
ilm_ptr.peer_buff_ptr=peer_buff;
}
#endif // #if defined(__MOD_NVRAM__)
/* FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) */
FT_SEND_MSG(MOD_FT, MOD_TST, FT_TST_SAP, MSG_ID_FT_TO_TST, &ilm_ptr);
}
else
{
#if !defined(NVRAM_NOT_PRESENT)
ft_misc_cal_data_read_from_nvram_cnf(cnf_result,peer_buff);
free_peer_buff(peer_buff);
#endif // #if !defined(NVRAM_NOT_PRESENT)
}
}
/*****************************************************************************
* 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 */
/*****************************************************************************
* FUNCTION
* phb_control_block_construct
* DESCRIPTION
* Initializer of control_block.
*
* Note:
* control_block_init() DOES NOT free local_param_ptr, peer_buf_ptr and data.
* It just set the pointers NULL.
* Hence, to prevent memory leak, user of control_block must explicitly frees the memory
* before calling control_block_alloc().
* PARAMETERS
* control_block [IN] The control_block
* ID [IN]
* RETURNS
* void
*****************************************************************************/
void phb_control_block_construct(control_block_type *control_block, kal_uint8 ID)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint8 access_id;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
/* Referenced control_block shall not be NULL) */
ASSERT(control_block != NULL);
access_id = control_block->ID;
if ((control_block->need_free_peer) && (control_block->peer_buf_ptr != NULL))
{
free_peer_buff((peer_buff_struct*) control_block->peer_buf_ptr);
}
kal_mem_set(control_block, (unsigned char)0, sizeof(control_block_type));
access_id = ((access_id + 0x10) & 0xF0); /* reserve 4bit for ID */
control_block->ID = (ID | access_id);
}
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;
}
void FT_WriteTo_NVRAM(ft_nvram_write_req_struct_T* req, peer_buff_struct* peer_buff, ilm_struct* ptrMsg)
{
ilm_struct ilm_ptr;
nvram_write_req_struct *nvram_ptr_loc_para;
kal_uint16 pdu_length;
kal_uint8 *pdu_ptr = get_peer_buff_pdu( 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_peer_buff_pdu( 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__
FT_ALLOC_OTHER_MSG(&ilm_ptr ,sizeof(nvram_write_req_struct));
nvram_ptr_loc_para=(nvram_write_req_struct *)(ilm_ptr.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);
}
ilm_ptr.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, &ilm_ptr);
if(ptrMsg != NULL)
ptrMsg->peer_buff_ptr=NULL;/* make sure the NVRAM will release the mem*/
}
/*************************************************************************
* FUNCTION
* ccci_ipc_send_msg
*
* DESCRIPTION
* This function is the internal api to send message
*
* PARAMETERS
* ipc_task_id -
* buffer_ptr -
* msg_size -
* wait_mode -
* message_to_head -
*
* RETURNS
* status - success/fail
*
*************************************************************************/
kal_bool ccci_ipc_send_msg(kal_uint32 ipc_task_id, void *buffer_ptr, kal_uint16 msg_size, kal_wait_mode wait_mode, kal_bool message_to_head)
{
kal_uint32 i, j ;
kal_uint32 retrieved_events = 0, orig_local_addr = 0 , orig_peer_addr = 0, update_buff_addr=0;
kal_int32 result = CCCI_SUCCESS;
ipc_ilm_t *temp_ipc_ilm = (ipc_ilm_t *)buffer_ptr;
ccci_io_request_t ior = {0};
CCCI_BUFF_T *p_ccci_buff;
kal_uint32 len = 0;
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_TRA);
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_TRA_ILM,
temp_ipc_ilm, temp_ipc_ilm->src_mod_id, temp_ipc_ilm->dest_mod_id,
temp_ipc_ilm->sap_id, temp_ipc_ilm->msg_id,
temp_ipc_ilm->local_para_ptr, temp_ipc_ilm->peer_buff_ptr);
/* get ext queue id from mapping table of task id - destnation*/
for (i = 0; i < MAX_CCCI_IPC_TASKS; i++)
{
if ( ccci_ipc_maptbl[i].task_id == ipc_task_id )
{
break;
}
}
/* get ext queue id from mapping table of task id - source*/
for (j = 0; j < MAX_CCCI_IPC_TASKS; j++)
{
if ( ccci_ipc_maptbl[j].task_id == temp_ipc_ilm->src_mod_id )
{
break;
}
}
/* check src mod id, if it's not defined in CCCI IPC, don't set used bit */
if(j >= MAX_CCCI_IPC_TASKS)
{
ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_TASKID_ERROR, ipc_task_id, temp_ipc_ilm->src_mod_id);
return KAL_FALSE;
}
/* check if the extquque id can not be found */
if (i >= MAX_CCCI_IPC_TASKS)
{
ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_TASKID_ERROR, ipc_task_id, temp_ipc_ilm->src_mod_id);
((CCCI_IPC_ILM_T*)buffer_ptr)->used = 0;
return KAL_FALSE;
}
/* check if the extquque id is to AP */
if ((ccci_ipc_maptbl[i].extq_id & AP_UINFY_ID_FLAG) == 0)
{
ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_DESTID_ERROR, ipc_task_id);
((CCCI_IPC_ILM_T*)buffer_ptr)->used = 0;
return KAL_FALSE;
}
/* check if the ilm buffer is from ipc_msgsvc_allocate_ilm or not */
if (buffer_ptr != &ccci_ipc_ilm_arr[j].ipc_ilm){
ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_ILM_ERROR);
return KAL_FALSE;
}
len = sizeof(CCCI_BUFF_T) + sizeof(ipc_ilm_t);
if (temp_ipc_ilm->local_para_ptr != NULL){
len+= temp_ipc_ilm->local_para_ptr->msg_len ;
}
if( temp_ipc_ilm->peer_buff_ptr != NULL){
len+= sizeof(peer_buff_struct)
+ temp_ipc_ilm->peer_buff_ptr->pdu_len
+ temp_ipc_ilm->peer_buff_ptr->free_header_space
+ temp_ipc_ilm->peer_buff_ptr->free_tail_space;
}
//assert if ilm size > CCCI_IPC_GPD size
EXT_ASSERT(len < CCCI_IPC_GPD_SIZE, len, CCCI_IPC_GPD_SIZE, 0);
/* Use critical section to protect ENTER */
CCCI_IPC_ENTER_CRITICAL_SECTION
if (KAL_TRUE == kal_query_systemInit()){ // polling mode
ior.first_gpd = ccci_ipc_ch.p_polling_gpd;
ior.last_gpd = ccci_ipc_ch.p_polling_gpd;
}
else{
#ifdef __SDIOC_PULL_Q_ENH_DL__
ior.num_gpd =
#endif
qbmt_alloc_q_no_tail(
CCCI_IPC_GPD_TYPE, /* type */
1, /* buff_num */
(void **)(&ior.first_gpd), /* pp_head */
(void **)(&ior.last_gpd)); /* pp_tail */
if(ior.first_gpd == NULL){
ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_ALLOC_GPD_ERROR);
return KAL_FALSE;
}
}
//initialize GPD CCCI_Header content
p_ccci_buff = CCCIDEV_GET_QBM_DATAPTR(ior.first_gpd);
p_ccci_buff->data[1] = (kal_uint32)len;
p_ccci_buff->channel = (kal_uint32)ccci_ipc_ch.send_channel;
p_ccci_buff->reserved = (kal_uint32)ccci_ipc_maptbl[i].extq_id;
ccci_debug_add_seq(p_ccci_buff, CCCI_DEBUG_ASSERT_BIT); // add ccci seq
QBM_DES_SET_DATALEN(ior.first_gpd, p_ccci_buff->data[1]);
QBM_DES_SET_DATALEN(ior.first_gpd->p_data_tbd, p_ccci_buff->data[1]);
qbm_cal_set_checksum((kal_uint8 *)ior.first_gpd);
qbm_cal_set_checksum((kal_uint8 *)ior.first_gpd->p_data_tbd);
QBM_CACHE_FLUSH(ior.first_gpd, sizeof(qbm_gpd));
QBM_CACHE_FLUSH(ior.first_gpd->p_data_tbd, sizeof(qbm_gpd));
//copy ilm to GPD
temp_ipc_ilm->src_mod_id = ccci_ipc_maptbl[j].extq_id;
update_buff_addr = (kal_uint32)p_ccci_buff;
update_buff_addr += sizeof(CCCI_BUFF_T);
CCCI_KAL_MSG_TO_AP_MSG(temp_ipc_ilm->msg_id, temp_ipc_ilm->msg_id);
kal_mem_cpy((kal_uint8 *)update_buff_addr ,(kal_uint8 *)temp_ipc_ilm, sizeof(ipc_ilm_t));
if (temp_ipc_ilm->local_para_ptr != NULL){
//copy loca_para_struct to GPD
update_buff_addr += sizeof(ipc_ilm_t); //24 bytes
orig_local_addr = update_buff_addr;
kal_mem_cpy((kal_uint8 *)update_buff_addr,(kal_uint8 *)temp_ipc_ilm->local_para_ptr, temp_ipc_ilm->local_para_ptr->msg_len);
}
if( temp_ipc_ilm->peer_buff_ptr != NULL){
//copy peer buff_struct to GPD
if (temp_ipc_ilm->local_para_ptr != NULL){
update_buff_addr += temp_ipc_ilm->local_para_ptr->msg_len;//should be 4 bytes alignment??
}
else{
update_buff_addr += sizeof(ipc_ilm_t); //24 bytes
}
orig_peer_addr = update_buff_addr;
kal_mem_cpy((kal_uint8 *)update_buff_addr,(kal_uint8 *)temp_ipc_ilm->peer_buff_ptr,
sizeof(peer_buff_struct)
+ temp_ipc_ilm->peer_buff_ptr->pdu_len
+ temp_ipc_ilm->peer_buff_ptr->free_header_space
+ temp_ipc_ilm->peer_buff_ptr->free_tail_space);
}
free_local_para(temp_ipc_ilm->local_para_ptr);
temp_ipc_ilm->local_para_ptr = (local_para_struct *)orig_local_addr;//assign not NULL ptr to indicate there have content
free_peer_buff(temp_ipc_ilm->peer_buff_ptr);
temp_ipc_ilm->peer_buff_ptr = (peer_buff_struct *)orig_peer_addr;//assign not NULL ptr to indicate there have content
QBM_CACHE_FLUSH(p_ccci_buff, len);
if (KAL_TRUE == kal_query_systemInit()){ // polling mode
result = ccci_polling_io(ccci_ipc_ch.send_channel, ccci_ipc_ch.p_polling_gpd, KAL_TRUE);
CCCIDEV_RST_CCCI_COMM_GPD_LIST(ccci_ipc_ch.p_polling_gpd,ccci_ipc_ch.p_polling_gpd);
}
else{
result = ccci_ipc_ch.ccci_write_gpd(ccci_ipc_ch.send_channel, &ior, NULL);
if (KAL_INFINITE_WAIT == wait_mode && CCCI_SUCCESS == result){
/* Wait for feedabck by retrieve event */
kal_retrieve_eg_events(ccci_ipc_ch.event, 1 << i, KAL_AND_CONSUME, &retrieved_events, KAL_SUSPEND);
}
}
/* Exit critical section */
CCCI_IPC_EXIT_CRITICAL_SECTION
((CCCI_IPC_ILM_T*)buffer_ptr)->used = 0;
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_TRA_CCCI,
p_ccci_buff->data[0], p_ccci_buff->data[1], p_ccci_buff->channel, p_ccci_buff->reserved);
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_PASS_TRA);
/* Finish */
if (result == CCCI_SUCCESS){
return KAL_TRUE;
}
else{
return KAL_FALSE;
}
}
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);
}
