📄 phb_handler_read.c
字号:
msg_ptr = (nvram_read_cnf_struct*) ilm_ptr->local_para_ptr;
control_block->IO_stage = IO_NONE;
if (msg_ptr->result == NVRAM_IO_ERRNO_OK)
{
control_block->IO_cnf_receive = phb_read_ln_handler;
pdu_data = (nvram_ef_phb_ln_struct*) get_pdu_ptr(ilm_ptr->peer_buff_ptr, &length);
control_block->total += pdu_data->no_entry;
phb_read_ln_confirm(PHB_ERRNO_SUCCESS, pdu_data, control_block->src_id, control_block);
}
else
{
phb_read_ln_confirm(PHB_ERRNO_READ_FAIL, NULL, control_block->src_id, control_block);
}
}
else
{
phb_read_ln_confirm(PHB_ERRNO_FAIL, NULL, control_block->src_id, control_block);
}
}
/* else
phb_read_ln_confirm (PHB_ERRNO_BUSY, NULL,
control_block->src_id, control_block); */
}
else
{
phb_read_ln_confirm(PHB_ERRNO_FAIL, NULL, control_block->src_id, control_block);
}
}
/*****************************************************************************
* FUNCTION
* phb_read_ln_confirm
* DESCRIPTION
* This is phb_read_ln_confirm function of PHB module.
* PARAMETERS
* result [IN]
* record2 [?]
* src_id [IN]
* control_block [?]
* ilm_ptr(?) [IN] The primitives
* RETURNS
* void
*****************************************************************************/
static void phb_read_ln_confirm(
phb_errno_enum result,
nvram_ef_phb_ln_struct *record2,
kal_uint8 src_id,
control_block_type *control_block)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
l4cphb_read_ln_cnf_struct *param_ptr;
peer_buff_struct *peer_buff_ptr = NULL;
l4cphb_phb_ln_entry_array_struct *pdu_stream_ptr;
nvram_ef_phb_ln_struct *src_ptr;
kal_uint16 length;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
param_ptr = (l4cphb_read_ln_cnf_struct*)
construct_local_para((kal_uint16) sizeof(l4cphb_read_ln_cnf_struct), TD_CTRL);
param_ptr->src_id = src_id;
param_ptr->result = result;
param_ptr->cause = 0;
param_ptr->total = 0;
if (control_block != NULL)
{
if (control_block->secondary_ID >= PHB_LND_LID_START && control_block->secondary_ID < PHB_LNM_LID_START)
{
param_ptr->type = PHB_LND;
}
else if (control_block->secondary_ID >= PHB_LNM_LID_START && control_block->secondary_ID < PHB_LNR_LID_START)
{
param_ptr->type = PHB_LNM;
}
else if (control_block->secondary_ID >= PHB_LNR_LID_START && control_block->secondary_ID <= PHB_TOTAL_LN_LID)
{
param_ptr->type = PHB_LNR;
}
}
if ((result == PHB_ERRNO_SUCCESS) && (control_block->total > 0))
{
param_ptr->total = control_block->total;
pdu_stream_ptr = (l4cphb_phb_ln_entry_array_struct*)
l4cphb_alloc_ln_peer_buf(&peer_buff_ptr, param_ptr->total);
src_ptr = (nvram_ef_phb_ln_struct*) get_pdu_ptr((peer_buff_struct*) control_block->data, &length);
/* pdu_stream_ptr->no_array = param_ptr->total;
pdu_stream_ptr->array = (phb_ln_entry_struct *)get_ctrl_buffer
(sizeof (phb_ln_entry_struct) * param_ptr->total); */
kal_mem_cpy(pdu_stream_ptr->array, &src_ptr->array[0], sizeof(phb_ln_entry_struct) * src_ptr->no_entry);
if (record2 != NULL)
{
kal_mem_cpy(
&pdu_stream_ptr->array[src_ptr->no_entry],
&record2->array[0],
sizeof(phb_ln_entry_struct) * record2->no_entry);
}
}
#if (MAX_PHB_LN_ENTRY > 20)
if (control_block && (control_block->total == PHB_MAX_LN_ENTRIES * 2) &&
control_block->actual_count > control_block->total)
{
param_ptr->more_data = KAL_TRUE;
}
else
{
param_ptr->more_data = KAL_FALSE;
}
#endif /* (MAX_PHB_LN_ENTRY > 20) */
phb_send_ilm(MOD_L4C, MSG_ID_L4CPHB_READ_LN_CNF, param_ptr, peer_buff_ptr);
/* if (peer_buff_ptr != NULL)
free_ctrl_buffer (pdu_stream_ptr->array); */
if (control_block != NULL)
{
if (control_block->data != NULL)
{
free_peer_buff((peer_buff_struct*) control_block->data);
}
phb_free_control_block(control_block);
}
} /* end of phb_read_ln_confirm */
#ifdef __PHB_USIM_SUPPORT__
/*****************************************************************************
* FUNCTION
* phb_read_email_handler
* DESCRIPTION
* This is phb_read_handler function of PHB module.
* Read SOP:
* phb_control_block_set_param(),
* phb_control_block_set(),
* phb_control_block_set_IO(),
* se_control_block()
* PARAMETERS
* ilm_ptr [IN] The primitives
* control_block [?]
* RETURNS
* void
*****************************************************************************/
void phb_read_email_handler(ilm_struct *ilm_ptr, control_block_type *control_block)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, FUNC_PHB_READ);
if (ilm_ptr != NULL)
{
l4cphb_read_req_struct *l4cphb_read_req;
l4cphb_read_req = (l4cphb_read_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_read_confirm(PHB_ERRNO_BUSY, 0, l4cphb_read_req->src_id, ilm_ptr->msg_id, control_block);
return;
}
control_block->src_id = l4cphb_read_req->src_id;
/* Retain msg_id */
control_block->cnf_msg_id = ilm_ptr->msg_id;
if (phb_ptr->state == PHB_STATE_READY)
{
if (control_block->proc_stage == READ_NONE)
{
l4cphb_phb_entry_array_struct *phb_entry_array;
phb_entry_struct *phb_entry;
peer_buff_struct *peer_buf_ptr;
/* Invalid parameters */
if (phb_is_read_param_valid(l4cphb_read_req) == KAL_FALSE)
{
control_block->actual_count = 0;
control_block->cause = PHB_ERRNO_READ_EMPTY;
phb_read_confirm(
PHB_ERRNO_READ_EMPTY,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
return;
}
/* If request total is 0, or nothing can be read, return READ_SUCCESS with total = 0 */
if (l4cphb_read_req->total == 0)
{
control_block->actual_count = 0;
control_block->cause = PHB_ERRNO_READ_EMPTY;
phb_read_confirm(
PHB_ERRNO_READ_EMPTY,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
return;
}
/**
* Read SOP:
* phb_control_block_set_param(),
* phb_control_block_set(),
* phb_control_block_set_IO(),
* se_control_block()
*/
control_block->total = l4cphb_read_req->total;
phb_entry_array =
(l4cphb_phb_entry_array_struct*) l4cphb_alloc_peer_buf(&peer_buf_ptr, control_block->total);
control_block->need_free_peer = KAL_TRUE;
phb_control_block_set_param(control_block, READ_CONTINUE, NULL, peer_buf_ptr);
phb_entry = &phb_entry_array->array[0];
if (l4cphb_read_req->type == PHB_ECC)
{
kal_uint8 i;
kal_uint8 index = (kal_uint8) l4cphb_read_req->index - 1;
phb_entry_struct *phb_entry_ith = phb_entry;
control_block->type = PHB_ECC;
control_block->total = 0;
/* phb_ptr->ecc.num_ecc now contains number of records */
for (i = index; (i < phb_ptr->ecc.num_ecc) && (control_block->total < l4cphb_read_req->total); ++i)
{
kal_uint16 len;
phb_entry_ith->storage = PHB_SIM;
len = bcd_len(&phb_ptr->ecc.ecc[i * NUM_OF_BYTE_ECC], NUM_OF_BYTE_ECC);
len = (len + 1) >> 1;
phb_entry_ith->tel_number.addr_length = len + L4_ADDR_BCD_TON_NPI_SIZE;
phb_entry_ith->tel_number.addr_bcd[L4_ADDR_BCD_TON_NPI_OFFSET] = TON_NPI_DEFAULT;
kal_mem_cpy(
&phb_entry_ith->tel_number.addr_bcd[L4_ADDR_BCD_TEL_NUM_OFFSET],
(void const*)&phb_ptr->ecc.ecc[i * NUM_OF_BYTE_ECC],
len);
++control_block->total;
phb_entry_ith->tel_number.addr_bcd[phb_entry_ith->tel_number.addr_length] = 0xff;
++phb_entry_ith;
}
phb_entry_array->no_array = (kal_uint8) (control_block->actual_count = control_block->total);
phb_read_confirm(
PHB_ERRNO_READ_SUCCESS,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
return;
}
else
{
phb_control_block_set(
control_block,
phb_read_continue,
phb_read_handler,
phb_read_err_handler,
READ_NONE);
/* This function sets actual_count */
phb_control_block_set_IO(
control_block,
l4cphb_read_req->type,
l4cphb_read_req->index,
l4cphb_read_req->total);
/* Set proc_stage, storage, record_index, primary_ID, and secondary_ID */
if (phb_se_set_control_block(
control_block,
OP_READ,
l4cphb_read_req->storage,
l4cphb_read_req->record_index) == KAL_FALSE)
{
phb_read_err_handler(NULL, control_block);
return;
}
control_block->data = (kal_uint8*) phb_entry;
control_block->length = phb_data_desc_get_record_size(phb_data_desc_get_desc_by_ID(control_block->primary_ID));
phb_read_continue(NULL, control_block);
}
}
/* error */
else
{
phb_read_err_handler(NULL, control_block);
return;
}
}
/* error */
else
{
kal_trace(TRACE_ERROR, ERROR_PHB_STATE);
control_block->actual_count = 0;
phb_read_confirm(
PHB_ERRNO_NOT_READY,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
return;
}
}
else
{
if (control_block->proc_stage == READ_CONTINUE)
{
phb_read_confirm(
PHB_ERRNO_READ_SUCCESS,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
}
else if (control_block->proc_stage == READ_CONTINUE_SPECIFIC)
{
if (control_block->data == NULL)
{
phb_read_confirm(
PHB_ERRNO_READ_EMPTY,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
}
else
{
phb_read_confirm(
PHB_ERRNO_READ_SUCCESS,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
}
}
/* error */
else
{
phb_read_err_handler(NULL, control_block);
return;
}
}
} /* end of phb_read_handler */
#endif /* __PHB_USIM_SUPPORT__ */ /* __PHB_USIM_SUPPORT */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -