/*!
@brief _fta_manage_check_exportable
check data for exportable
@param [out] fta_manager check data
@param [in] limit_size data size
@retval TRUE : data is exportable
@retval FALSE: data is not exportable
*/
boolean _fta_manage_check_exportable(fta_manager_store_header *fta_manager, uint32 limit_size)
{
if(fta_manager == NULL) return FALSE;
if(!(fta_manager->cmn.tag == FTA_TAG_MANAGER &&
fta_manager->cmn.size >= FTA_CALC_MANAGER_SIZE(fta_manager->count) &&
fta_manager->cmn.size <= limit_size &&
fta_manager->cmn.offset == FTA_MANAGER_STORE_HEADER_LEN &&
fta_manager->reclen == FTA_MANAGER_STORE_ITEM_LEN &&
fta_manager->count > 0)) {
return FALSE;
}
if(fta_lib_check_parity16((uint16 *)fta_manager, fta_manager->cmn.size / 2, 0) != 0) {
return FALSE;
}
if(!(fta_manager->cmn.enabled == FTA_STORE_ENABLED_TRUE &&
FTA_LIB_CHECKBIT(fta_manager->cmn.statbit, FTA_STORE_STATBIT_RECORDING))) {
return FALSE;
}
FTA_LIB_CHANGEBIT_CLR(fta_manager->cmn.statbit, FTA_STORE_STATBIT_RECORDING);
fta_manager->parity = fta_lib_check_parity16(
(uint16 *)fta_manager,
fta_manager->cmn.size / 2,
fta_manager->parity);
return TRUE;
}
/*!
@brief _fta_var_alloc_i
allocate the list record(internal)
@param [in] var_header header of the area
@param [in] access_info access information
@param [in] key_info key
@param [in] alloc_len size of the record
@retval NULL: over the max record
@retval others: pointer of record
*/
static void *_fta_var_alloc_i(fta_var_store_header *var_header,
const fta_var_record_access_info *access_info, const void *key_info, uint32 alloc_len)
{
uint8 *var_dataarea;
void *var_record = NULL;
uint32 key_size;
uint32 datalen_size;
uint32 datalen;
if(!FTA_LIB_CHECKBIT(var_header->cmn.statbit, FTA_STORE_STATBIT_RECORDING)) {
goto _fta_var_alloc_exit;
}
key_size = access_info->key_size;
datalen_size = access_info->datalen_size;
if(alloc_len < key_size + datalen_size ||
alloc_len > var_header->cmn.size - var_header->cmn.offset) {
goto _fta_var_alloc_exit;
}
datalen = alloc_len - (key_size + datalen_size);
if((datalen_size == 0 && datalen > 0) ||
(datalen_size == 1 && datalen > 0xFF) ||
(datalen_size == 2 && datalen > 0xFFFF) ||
(datalen_size == 3 && datalen > 0xFFFFFF)) {
goto _fta_var_alloc_exit;
}
alloc_len = FTA_LIB_ALIGN4_32(alloc_len);
if(access_info->check_func != NULL) {
if(access_info->check_func(var_header, key_info, alloc_len) == FALSE) {
goto _fta_var_alloc_exit;
}
}
if(alloc_len > var_header->cmn.size - var_header->cmn.offset - var_header->bottom) {
goto _fta_var_alloc_exit;
}
var_dataarea = FTA_LIB_OFFSET_ADDR(var_header, var_header->cmn.offset);
/* append the record */
var_record = (void *)FTA_LIB_OFFSET_ADDR(var_dataarea, var_header->bottom);
memcpy(var_record, key_info, key_size);
if(datalen_size > 0) {
if(datalen_size <= sizeof(uint32)) {
memcpy(FTA_LIB_OFFSET_ADDR(var_record, key_size), &datalen, datalen_size);
} else {
memcpy(FTA_LIB_OFFSET_ADDR(var_record, key_size), &datalen, sizeof(uint32));
memset(FTA_LIB_OFFSET_ADDR(var_record, key_size + sizeof(uint32)), 0, datalen_size - sizeof(uint32));
}
}
var_header->count++;
var_header->bottom += alloc_len;
_fta_var_alloc_exit:
;
return var_record;
}
/*!
@brief _fta_lisext_hash_record?i
internal functionn of operating the list hash record
@param [in] p_store_item item for manage
@param [in] access_info access information
@param [in] key_info key
@param [in] access_type FTA_LISTEX_HASH_ACCESS_GET: get record
FTA_LISTEX_HASH_ACCESS_ADD: add record
FTA_LISTEX_HASH_ACCESS_DEL: del record
@retval NULL: not found / over the max record
@retval others: pointer of record
*/
static void *_fta_listex_hash_record_i(fta_list_store_header *list_header,
const fta_listex_hash_access_info *access_info,
const void *key_info, uint32 access_type)
{
uint8 *list_dataarea;
void *list_record = NULL;
uint32 fixed_len;
uint32 key_size;
uint32 record_par;
uint32 record_num;
fta_listex_hash_id_type *work_buffer;
boolean not_found;
/* check of a recordable state or an effective state */
if(access_type != FTA_LISTEX_HASH_ACCESS_GET) {
if(!FTA_LIB_CHECKBIT(list_header->cmn.statbit, FTA_STORE_STATBIT_RECORDING)) {
goto _fta_listex_hash_record_exit;
}
} else {
if(list_header->cmn.enabled != FTA_STORE_ENABLED_TRUE) {
goto _fta_listex_hash_record_exit;
}
}
fixed_len = FTA_LIB_ALIGN4_32(access_info->fixed_len);
key_size = access_info->key_size;
list_dataarea = FTA_LIB_OFFSET_ADDR(list_header, list_header->cmn.offset);
work_buffer = access_info->work_buffer;
/* registered check */
not_found = TRUE;
record_par = 0;
memcpy(&record_par, key_info, (key_size > sizeof(uint32) ? sizeof(uint32) : key_size));
record_par %= access_info->hash_size; /* only to 4 bytes of low rank */
record_par += FTA_LISTEX_HASH_BUF_HASHEDINDEX;
if(list_header->count > 0) {
/* search for the same item */
record_num = work_buffer[record_par];
while(record_num != FTA_LISTEX_HASH_ID_EMPTY) {
list_record = (void *)FTA_LIB_OFFSET_ADDR(list_dataarea, record_num * fixed_len);
if(memcmp(key_info, list_record, key_size) == 0) {
not_found = FALSE;
break;
}
record_par = record_num;
record_num = work_buffer[record_par];
}
}
if(not_found) {
/* add record */
if(access_type == FTA_LISTEX_HASH_ACCESS_ADD) {
if(list_header->count == 0) {
/* simple work area check only once after initialization */
if(work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_BEGIN] != FTA_LISTEX_HASH_ID_EMPTY ||
work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_END] != FTA_LISTEX_HASH_ID_EMPTY ||
work_buffer[FTA_LISTEX_HASH_BUF_HASHEDINDEX] != FTA_LISTEX_HASH_ID_EMPTY ) {
FTA_LOG_MESSAGE(FTA_LIST, FTA_LOG_LEVEL_CRITICAL, "*** FTA LIST CONFIG ERROR", 0, 0, 0);
list_record = NULL;
goto _fta_listex_hash_record_exit;
}
}
/* a new record is added */
if((uint32)(list_header->count) >= access_info->entry_max) {
/* acquires from an empty list when the number of registration is a maximum */
record_num = work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_BEGIN];
if(record_num == FTA_LISTEX_HASH_ID_EMPTY) {
list_record = NULL;
goto _fta_listex_hash_record_exit;
}
/* deletes from an empty list */
work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_BEGIN] = work_buffer[record_num];
if(work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_END] == record_num) {
work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_END] = FTA_LISTEX_HASH_ID_EMPTY;
}
} else {
/* adds a new record until the number of registration is a maximum*/
record_num = list_header->count;
list_header->count++;
list_header->bottom = list_header->count * fixed_len;
}
/* adds to hash table */
work_buffer[record_num] = work_buffer[record_par];
work_buffer[record_par] = (fta_listex_hash_id_type)record_num;
/* return the record position */
list_record = (void *)FTA_LIB_OFFSET_ADDR(list_dataarea, record_num * fixed_len);
memcpy(list_record, key_info, key_size);
} else {
/* do noting */
list_record = NULL;
}
} else {
/* delete record */
if(access_type == FTA_LISTEX_HASH_ACCESS_DEL) {
/* set the delete bit */
((uint8*)list_record)[key_size - 1] |= 0x80;
/* deletes from the list and adds to an empty entry */
work_buffer[record_par] = work_buffer[record_num];
work_buffer[record_num] = FTA_LISTEX_HASH_ID_EMPTY;
if(work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_BEGIN] == FTA_LISTEX_HASH_ID_EMPTY) {
/* with no empty entry */
work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_BEGIN] = (fta_listex_hash_id_type)record_num;
work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_END] = (fta_listex_hash_id_type)record_num;
} else {
/* add to a termination */
work_buffer[work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_END]] = (fta_listex_hash_id_type)record_num;
work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_END] = (fta_listex_hash_id_type)record_num;
}
}
}
_fta_listex_hash_record_exit: ;
return list_record;
}
