static void *ESIF_CALLCONV EsifEventMgr_EventQueueThread(void *ctxPtr)
{
EsifEventQueueItemPtr queueEventPtr = NULL;
UNREFERENCED_PARAMETER(ctxPtr);
while(!g_EsifEventMgr.eventQueueExitFlag) {
queueEventPtr = esif_queue_pull(g_EsifEventMgr.eventQueuePtr);
if (NULL == queueEventPtr) {
continue;
}
ESIF_TRACE_INFO("Dequeuing %s event for Part. %u Dom. 0x%04X\n",
esif_event_type_str(queueEventPtr->eventType),
queueEventPtr->participantId,
queueEventPtr->domainId);
EsifEventMgr_ProcessEvent(queueEventPtr->participantId,
queueEventPtr->domainId,
queueEventPtr->eventType,
&queueEventPtr->eventData);
esif_ccb_free(queueEventPtr->eventData.buf_ptr);
esif_ccb_free(queueEventPtr);
}
return 0;
}
// Uninitialize Pathname List
void esif_pathlist_exit(void)
{
int j;
for (j = 0; g_pathlist.pathlist != NULL && j < g_pathlist.num_paths; j++) {
esif_ccb_free(g_pathlist.pathlist[j]);
}
esif_ccb_free(g_pathlist.pathlist);
memset(&g_pathlist, 0, sizeof(g_pathlist));
}
static void EsifEventMgr_QueueDestroyCallback(void *ctxPtr)
{
EsifEventQueueItemPtr queueEventPtr = (EsifEventQueueItemPtr)ctxPtr;
if(queueEventPtr != NULL) {
esif_ccb_free(queueEventPtr->eventData.buf_ptr);
esif_ccb_free(queueEventPtr);
}
}
static void EsifDataLogCleanup()
{
if (dataLogContextPtr != NULL) {
esif_ccb_timer_kill(dataLogContextPtr->dataLogScheduleTimer);
esif_ccb_free(dataLogContextPtr->dataLogScheduleTimer);
esif_ccb_free(dataLogContextPtr->dataLogParticipantList);
esif_ccb_free(dataLogContextPtr);
dataLogContextPtr = NULL;
}
}
// Read a Registry Key Value into a specified memory buffer
static eEsifError DataVault_ReadRegistry (
DataVaultPtr self,
esif_string keyname,
void * *buffer,
UInt32 *buf_size
)
{
eEsifError rc = ESIF_E_UNSPECIFIED;
HKEY hKey = 0;
DWORD dwFlags = RRF_RT_ANY;
DWORD dwError = 0;
DWORD dwSize = 0;
char *regkey = 0;
char *valuename = 0;
u32 j;
UNREFERENCED_PARAMETER(self);
// Format: HKLM\Subkey\Path\ValueName
for (j = 0; HKeyList[j].name; j++) {
size_t namelen = esif_ccb_strlen(HKeyList[j].name, 30);
if (esif_ccb_strnicmp(HKeyList[j].name, keyname, namelen) == 0 && keyname[namelen] == '\\') {
hKey = HKeyList[j].hkey;
keyname += esif_ccb_strlen(HKeyList[j].name, 30) + 1;
break;
}
}
if (!hKey) {
return rc;
}
regkey = esif_ccb_strdup(keyname);
if ((valuename = strrchr(regkey, '\\')) == 0) {
esif_ccb_free(regkey);
return rc;
}
*valuename++ = 0;
// Get Data Size from Registry and copy into buffer if found
if ((dwError = RegGetValueA(hKey, regkey, valuename, dwFlags, NULL, 0, &dwSize)) == 0) {
void *reg_buf = esif_ccb_malloc(dwSize);
dwError = RegGetValueA(hKey, regkey, valuename, dwFlags, NULL, reg_buf, &dwSize);
if (dwError == 0) {
*buffer = reg_buf;
*buf_size = dwSize;
rc = ESIF_OK;
} else {
esif_ccb_free(reg_buf);
}
} else {
rc = ESIF_E_NOT_FOUND;
}
esif_ccb_free(regkey);
return rc;
}
void esif_dsp_table_destroy()
{
UInt8 i;
ESIF_TRACE_INFO("Destroy DSP Table");
for (i = 0; i < g_dm.dme_count; i++) {
esif_dsp_destroy(g_dm.dme[i].dsp_ptr);
esif_ccb_free(g_dm.dme[i].file_ptr);
esif_ccb_free(g_dm.dme[i].fpc_ptr);
esif_ccb_memset(&g_dm.dme[i], 0, sizeof(g_dm.dme[i]));
}
g_dm.dme_count = 0;
}
static void esif_ws_http_process_post (const char *buffer)
{
char *begPtr;
char *endPtr;
char *namebox;
char *nameboxVal = NULL;
char *passwordbox;
char *passwordboxVal = NULL;
size_t namebox_size;
size_t passwordbox_size;
printf("buffer from POST: %s\n", buffer);
namebox = strstr(buffer, "namebox");
if (namebox) {
begPtr = strchr((const char*)namebox, '=');
begPtr++;
endPtr = strchr(begPtr, '&');
namebox_size = endPtr - begPtr;
nameboxVal = (char*)esif_ccb_malloc(namebox_size + 1);
if (NULL == nameboxVal) {
exit(1);
}
esif_ccb_memcpy(nameboxVal, namebox + 8, namebox_size + 1);
nameboxVal[namebox_size] = 0;
printf("name: %s ", nameboxVal);
}
passwordbox = strstr(buffer, "passwordbox");
if (passwordbox) {
begPtr = strchr((const char*)passwordbox, '=');
begPtr++;
endPtr = strchr(begPtr, '&');
passwordbox_size = endPtr - begPtr;
passwordboxVal = (char*)esif_ccb_malloc(passwordbox_size + 1);
if (NULL == passwordboxVal) {
exit(1);
}
esif_ccb_memcpy(passwordboxVal, passwordbox + 12, passwordbox_size + 1);
passwordboxVal[passwordbox_size] = 0;
printf("password: %s\n", passwordboxVal);
}
if (nameboxVal) {
esif_ccb_free(nameboxVal);
}
if (passwordboxVal) {
esif_ccb_free(passwordboxVal);
}
}
void esif_ws_protocol_initialize(ProtocolPtr protPtr)
{
esif_ccb_free(protPtr->hostField);
esif_ccb_free(protPtr->originField);
esif_ccb_free(protPtr->webpage);
esif_ccb_free(protPtr->keyField);
esif_ccb_free(protPtr->web_socket_field);
protPtr->hostField = NULL;
protPtr->originField = NULL;
protPtr->webpage = NULL;
protPtr->keyField = NULL;
protPtr->web_socket_field = NULL;
protPtr->frameType = EMPTY_FRAME;
}
/* Destroy Hash Table */
void esif_ht_destroy(
struct esif_ht *self,
item_destroy_func item_destroy_fptr
)
{
u32 index = 0;
if ((self == NULL) || (self->table == NULL)) {
ESIF_TRACE_ERROR("Hash table ptr NULL\n");
goto exit;
}
ESIF_TRACE_DYN_VERB("Destroying hash table %p\n", self);
for (index = 0; index < self->size; ++index) {
if (self->table[index] == NULL)
continue;
ESIF_TRACE_DYN_VERB("Destroy linked list %d\n", index);
esif_destroy_ht_nodes(self->table[index], item_destroy_fptr);
esif_link_list_destroy(self->table[index]);
self->table[index] = NULL;
}
esif_ccb_free(self->table);
esif_ccb_mempool_free(ESIF_MEMPOOL_TYPE_HASH2, self);
exit:
return;
}
/* This should only be called when shutting down */
static eEsifError EsifUpManagerDestroyParticipants(void)
{
eEsifError rc = ESIF_OK;
EsifUpManagerEntryPtr entry_ptr = NULL;
UInt8 i = 0;
esif_ccb_write_lock(&g_uppMgr.fLock);
for (i = 0; i < MAX_PARTICIPANT_ENTRY; i++) {
entry_ptr = &g_uppMgr.fEntries[i];
if (entry_ptr->fState > ESIF_PM_PARTICIPANT_REMOVED) {
g_uppMgr.fEntryCount--;
}
entry_ptr->fState = ESIF_PM_PARTICIPANT_STATE_AVAILABLE;
if (NULL != entry_ptr->fUpPtr) {
esif_ccb_free(entry_ptr->fUpPtr);
entry_ptr->fUpPtr = NULL;
}
}
esif_ccb_write_unlock(&g_uppMgr.fLock);
ESIF_TRACE_INFO("The participants are destroyed in ESIF UF participant manager\n");
return rc;
}
int EsifLogFile_Open(EsifLogType type, const char *filename, int append)
{
int rc=0;
char fullpath[MAX_PATH]={0};
char mode[3] = {(append ? 'a' : 'w'), 0, 0};
esif_ccb_write_lock(&g_EsifLogFile[type].lock);
if (g_EsifLogFile[type].handle != NULL)
esif_ccb_fclose(g_EsifLogFile[type].handle);
EsifLogFile_GetFullPath(fullpath, sizeof(fullpath), filename);
#ifdef ESIF_ATTR_OS_WINDOWS
mode[1] = 'c';
g_EsifLogFile[type].handle = _fsopen(fullpath, mode, _SH_DENYWR);
if (g_EsifLogFile[type].handle == NULL)
rc = errno;
#else
rc = esif_ccb_fopen(&g_EsifLogFile[type].handle, fullpath, mode);
#endif
if (rc == 0) {
esif_ccb_free(g_EsifLogFile[type].filename);
g_EsifLogFile[type].filename = esif_ccb_strdup((char *)fullpath);
}
esif_ccb_write_unlock(&g_EsifLogFile[type].lock);
return rc;
}
void EsifActMgrExit()
{
u8 i = 0;
EsifActPtr a_act_ptr = NULL;
ESIF_TRACE_ENTRY_INFO();
/* Call before destroying action manager */
EsifActExit();
if (NULL != g_actMgr.fActTypes) {
esif_link_list_destroy(g_actMgr.fActTypes);
g_actMgr.fActTypes = NULL; //set to null so that it will be caught if mid-execution
}
esif_ccb_read_lock(&g_actMgr.fLock);
for (i = 0; i < ESIF_MAX_ACTIONS; i++) {
a_act_ptr = &g_actMgr.fEnrtries[i];
esif_ccb_free(a_act_ptr->fLibNamePtr);
esif_ccb_library_unload(a_act_ptr->fLibHandle);
esif_ccb_memset(a_act_ptr, 0, sizeof(*a_act_ptr));
}
esif_ccb_read_unlock(&g_actMgr.fLock);
esif_ccb_lock_uninit(&g_actMgr.fLock);
ESIF_TRACE_EXIT_INFO();
}
void EsifAppMgrExit()
{
u8 i = 0;
EsifAppPtr a_app_ptr = NULL;
ESIF_TRACE_ENTRY_INFO();
EsifEventMgr_UnregisterEventByType(ESIF_EVENT_PARTICIPANT_SUSPEND, EVENT_MGR_MATCH_ANY, EVENT_MGR_DOMAIN_D0, EsifAppMgr_EventCallback, NULL);
EsifEventMgr_UnregisterEventByType(ESIF_EVENT_PARTICIPANT_RESUME, EVENT_MGR_MATCH_ANY, EVENT_MGR_DOMAIN_D0, EsifAppMgr_EventCallback, NULL);
EsifAppExit();
ESIF_TRACE_DEBUG("Exit Action Manager (APPMGR)");
esif_ccb_read_lock(&g_appMgr.fLock);
for (i = 0; i < ESIF_MAX_APPS; i++) {
a_app_ptr = &g_appMgr.fEntries[i];
// Attempt to gracefully shutdown App before forcing library unload
if (a_app_ptr->fLibNamePtr != NULL) {
EsifAppStop(a_app_ptr);
}
if (a_app_ptr->fLibNamePtr != NULL) {
esif_ccb_library_unload(a_app_ptr->fLibHandle);
esif_ccb_free(a_app_ptr->fLibNamePtr);
esif_ccb_memset(a_app_ptr, 0, sizeof(*a_app_ptr));
}
}
esif_ccb_read_unlock(&g_appMgr.fLock);
esif_ccb_lock_uninit(&g_appMgr.fLock);
ESIF_TRACE_EXIT_INFO();
}
void EsifAct_DestroyAction(
EsifActPtr self
)
{
if (NULL == self) {
goto exit;
}
self->markedForDelete = ESIF_TRUE;
EsifAct_PutRef(self);
ESIF_TRACE_INFO("Destroy action %d : waiting for delete event...\n", self->type);
esif_ccb_event_wait(&self->deleteEvent);
EsifAct_UnregisterEvents(self);
EsifAct_CallIfaceDestroy(self);
esif_ccb_event_uninit(&self->deleteEvent);
esif_ccb_lock_uninit(&self->objLock);
esif_ccb_free(self);
exit:
return;
}
static eEsifError EsifEventMgr_DumpGarbage()
{
eEsifError rc = ESIF_OK;
EsifLinkListPtr listPtr = g_EsifEventMgr.garbageList;
EsifLinkListNodePtr nodePtr = NULL;
EventMgrEntryPtr entryPtr = NULL;
if (NULL == listPtr) {
rc = ESIF_E_UNSPECIFIED;
goto exit;
}
esif_ccb_write_lock(&g_EsifEventMgr.listLock);
nodePtr = listPtr->head_ptr;
while(nodePtr) {
entryPtr = nodePtr->data_ptr;
/* remove the node first so that it isn't considered active while we disable events */
esif_link_list_node_remove(listPtr, nodePtr);
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
EsifEventMgr_DisableEvent(entryPtr);
esif_ccb_free(entryPtr);
esif_ccb_write_lock(&g_EsifEventMgr.listLock);
nodePtr = listPtr->head_ptr;
}
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
exit:
return rc;
}
/* IOCTL */
static int esif_ipc_ioctl(struct esif_ipc *ipc_user_ptr)
{
int rc = 0;
struct esif_ipc *ipc_req_ptr = esif_ipc_user_to_kernel(ipc_user_ptr);
struct esif_ipc *ipc_rsp_ptr = NULL;
if (NULL == ipc_req_ptr)
return -ENOMEM;
ESIF_TRACE_DYN_IPC("linux_%s: user %p kernel %p\n",
__func__,
ipc_user_ptr,
ipc_req_ptr);
ipc_rsp_ptr = esif_ipc_process(ipc_req_ptr);
if (NULL != ipc_rsp_ptr) {
esif_ipc_kernel_to_user((struct esif_ipc *)ipc_user_ptr,
ipc_rsp_ptr);
ESIF_TRACE_DYN_IPC("linux_%s: user %p kernel %p\n",
__func__,
ipc_user_ptr,
ipc_rsp_ptr);
if (ipc_req_ptr != ipc_rsp_ptr)
esif_ipc_free(ipc_rsp_ptr);
} else {
rc = -EINVAL;
}
esif_ccb_free(ipc_req_ptr);
return rc;
}
/* IOCTL */
static ssize_t esif_file_ipc(
struct file *fp,
char __user *buf,
size_t count,
loff_t *ppos
)
{
u32 len = 0;
struct esif_ipc *ipc_req_ptr = esif_ipc_user_to_kernel(
(struct esif_ipc *)buf);
struct esif_ipc *ipc_rsp_ptr = NULL;
if (count < sizeof(struct esif_ipc))
return -EINVAL;
if (NULL == ipc_req_ptr)
return -ENOMEM;
ESIF_TRACE_DYN_IPC("linux_%s: user %p kernel %p count %d\n",
__func__, buf, ipc_req_ptr, (int)count);
ipc_rsp_ptr = esif_ipc_process(ipc_req_ptr);
if (NULL != ipc_rsp_ptr) {
len = esif_ipc_kernel_to_user((struct esif_ipc *)buf,
ipc_rsp_ptr);
ESIF_TRACE_DYN_IPC("linux_%s: user %p kernel %p count = %d\n",
__func__, buf, ipc_rsp_ptr, (int)count);
if (ipc_req_ptr != ipc_rsp_ptr)
esif_ipc_free(ipc_rsp_ptr);
}
esif_ccb_free(ipc_req_ptr);
return len;
}
void ESIF_INLINE IString_dtor (IStringPtr self)
{
ESIF_ASSERT(self);
if (self->buf_len) {
esif_ccb_free(self->buf_ptr);
}
WIPEPTR(self);
}
static void EsifActMgr_DestroyEntry(
EsifActMgrEntryPtr entryPtr
)
{
if (NULL == entryPtr) {
goto exit;
}
EsifAct_DestroyAction(entryPtr->actPtr);
EsifActMgr_UnloadAction(entryPtr);
esif_ccb_free(entryPtr->libName);
esif_ccb_free(entryPtr);
exit:
return;
}
// Automatically Load all Static DataVaults and *.dv files in the current folder into the DataBank
eEsifError DataBank_LoadDataVaults (DataBankPtr self)
{
eEsifError rc = ESIF_OK;
esif_ccb_file_find_handle find_handle = INVALID_HANDLE_VALUE;
char file_path[MAX_PATH] = {0};
char file_pattern[MAX_PATH] = {0};
struct esif_ccb_file *ffd_ptr;
UInt32 idx;
ASSERT(self);
// Import all Static DataVaults into ReadOnly DataVaults
for (idx = 0; g_StaticDataVaults[idx].name; idx++) {
DataVaultPtr DB = DataBank_OpenNameSpace(self, g_StaticDataVaults[idx].name);
if (DB) {
IOStream_SetMemory(DB->stream, g_StaticDataVaults[idx].buffer, g_StaticDataVaults[idx].buf_len);
DB->flags |= (ESIF_SERVICE_CONFIG_READONLY | ESIF_SERVICE_CONFIG_NOCACHE);
DataVault_ReadVault(DB);
}
}
// Create DataVault Directory if it doesn't exit
esif_build_path(file_path, sizeof(file_path), ESIF_PATHTYPE_DV, NULL, NULL);
esif_ccb_makepath(file_path);
// Import all matching *.dv files into ReadWrite DataVaults
esif_ccb_sprintf(MAX_PATH, file_pattern, "*%s", ESIFDV_FILEEXT);
ffd_ptr = (struct esif_ccb_file*)esif_ccb_malloc(sizeof(*ffd_ptr));
if (NULL == ffd_ptr) {
rc = ESIF_E_NO_MEMORY;
}
if (rc == ESIF_OK) {
find_handle = esif_ccb_file_enum_first(file_path, file_pattern, ffd_ptr);
}
if (INVALID_HANDLE_VALUE != find_handle) {
do {
struct esif_ccb_file dv_file = {0};
DataVaultPtr DB = 0;
// Read DataVault File, unless it's already been loaded as a Static DataVault
if (esif_ccb_strlen(ffd_ptr->filename, MAX_PATH) > sizeof(ESIFDV_FILEEXT)) {
ffd_ptr->filename[esif_ccb_strlen(ffd_ptr->filename, MAX_PATH) - (sizeof(ESIFDV_FILEEXT) - 1)] = 0; // Truncate ".dv" extension
if (DataBank_GetNameSpace(self, ffd_ptr->filename) == NULL) {
DB = DataBank_OpenNameSpace(self, ffd_ptr->filename);
if (DB) {
esif_build_path(dv_file.filename, sizeof(dv_file.filename), ESIF_PATHTYPE_DV, DB->name, ESIFDV_FILEEXT);
IOStream_SetFile(DB->stream, dv_file.filename, "rb");
DataVault_ReadVault(DB);
}
}
}
} while (esif_ccb_file_enum_next(find_handle, file_pattern, ffd_ptr));
esif_ccb_file_enum_close(find_handle);
}
esif_ccb_free(ffd_ptr);
return rc;
}
void EsifLogMgrExit(void)
{
int j;
ESIF_TRACE_ENTRY_INFO();
for (j=0; j < MAX_ESIFLOG; j++) {
if (g_EsifLogFile[j].handle != NULL) {
esif_ccb_fclose(g_EsifLogFile[j].handle);
}
esif_ccb_free(g_EsifLogFile[j].name);
esif_ccb_free(g_EsifLogFile[j].filename);
esif_ccb_lock_uninit(&g_EsifLogFile[j].lock);
}
esif_ccb_memset(g_EsifLogFile, 0, sizeof(g_EsifLogFile));
ESIF_TRACE_EXIT_INFO();
}
// Close an nameSpace Iterator
void EsifConfigFindClose(
EsifConfigFindContextPtr context
)
{
if (context) {
esif_ccb_free(*context);
*context = NULL;
}
}
void DataBank_Destroy (DataBankPtr self)
{
UInt32 idx;
for (idx = 0; idx < self->size; idx++)
DataVault_dtor(&self->elements[idx]);
self->size = 0;
esif_ccb_lock_uninit(&self->lock);
esif_ccb_free(self);
}
static void esif_ws_cgi_parse_query (
char *query,
const char *beg_parms_loc_in_query,
int fd,
char *cgi_dir
)
{
char *cgi_script;
char *cgi_script_buf;
// char *cgi_dir;
char cgiParms[100];
size_t cgi_script_size;
#define MAX_SIZE 100
cgi_script_size = query - beg_parms_loc_in_query;
cgi_script = (char*)esif_ccb_malloc(cgi_script_size + 1);
if (cgi_script == NULL) {
exit(1);
}
// cgi_dir = (char*)esif_ccb_malloc(esif_ccb_strlen(cgi_dir, MAX_SIZE) + cgi_script_size);
// if (cgi_dir == NULL)
// exit(1);
esif_ccb_memcpy(cgi_script, beg_parms_loc_in_query, cgi_script_size);
// esif_ccb_memcpy(cgi_dir, DIRECTORY, esif_ccb_strlen(DIRECTORY, MAX_SIZE));
cgi_script[cgi_script_size] = '\0';
// cgi_dir[esif_ccb_strlen(DIRECTORY, MAX_SIZE)]='\0';
printf("cgi_script 1: %s\n", cgi_script);
query++;
cgi_script_buf = cgi_script;
#ifdef ESIF_ATTR_OS_WINDOWS
cgi_script_buf = (char*)strrchr(cgi_script_buf, '/');
cgi_script_buf++;
cgi_script_buf[esif_ccb_strlen(cgi_script_buf, MAX_SIZE)] = '\0';
#endif
esif_ccb_strcpy(cgiParms, query, esif_ccb_strlen(query, MAX_SIZE));
printf("cgi_dir: %s\n", cgi_dir);
printf("cgiParms 1: %s\n", cgiParms);
esif_ccb_strcat(cgi_dir, cgi_script_buf, sizeof(cgi_dir));
esif_ws_cgi_redirect_output(cgi_dir, fd);
if (cgi_script) {
esif_ccb_free(cgi_script);
}
// if (cgi_dir)
// esif_ccb_free(cgi_dir);
}
static void EsifEventMgr_LLEntryDestroyCallback(
void *dataPtr
)
{
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
EsifEventMgr_DisableEvent((EventMgrEntryPtr)dataPtr);
esif_ccb_free(dataPtr);
esif_ccb_write_lock(&g_EsifEventMgr.listLock);
}
/* This does not delete the item_ptr */
static void esif_destroy_ht_node(
struct esif_ht_node *ht_node
)
{
ESIF_ASSERT(ht_node != NULL);
if (ht_node->key_ptr)
esif_ccb_free(ht_node->key_ptr);
/* TODO: If needed */
/* We can call the callback destroy func here so that
* the caller does not have to destroy the item. Right
* now this is done before coming into this function
* for HT destroy only.
*/
esif_ccb_free(ht_node);
return;
}
// destructor
void StringList_dtor (StringListPtr self)
{
if (self) {
int i;
for (i = 0; i < self->items; i++)
String_Destroy(self->list[i]);
esif_ccb_free(self->list);
WIPEPTR(self);
}
}
static struct esif_ht_node *esif_alloc_ht_node(
u8 *key_ptr,
u32 key_length,
void *item_ptr
)
{
enum esif_rc rc = ESIF_OK;
struct esif_ht_node *ht_node_ptr = NULL;
ESIF_ASSERT(key_ptr != NULL);
ht_node_ptr =
(struct esif_ht_node *)esif_ccb_malloc(sizeof(*ht_node_ptr));
if (ht_node_ptr == NULL) {
ESIF_TRACE_ERROR("Unable to allocate HT node\n");
rc = ESIF_E_NO_MEMORY;
goto exit;
}
ht_node_ptr->key_ptr = esif_ccb_malloc(key_length);
if (ht_node_ptr->key_ptr == NULL) {
ESIF_TRACE_ERROR("Unable to allocate HT node key ptr\n");
rc = ESIF_E_NO_MEMORY;
goto exit;
}
esif_ccb_memcpy(ht_node_ptr->key_ptr, key_ptr, key_length);
ht_node_ptr->key_length = key_length;
ht_node_ptr->item_ptr = item_ptr;
exit:
if (rc != ESIF_OK) {
if (ht_node_ptr) {
if (ht_node_ptr->key_ptr)
esif_ccb_free(ht_node_ptr->key_ptr);
esif_ccb_free(ht_node_ptr);
ht_node_ptr = NULL;
}
}
return ht_node_ptr;
}
/* Free DSP Upper Instance */
static void esif_dsp_destroy(EsifDspPtr dspPtr)
{
if (NULL == dspPtr) {
return;
}
esif_ht_destroy(dspPtr->ht_ptr, NULL);
esif_link_list_destroy(dspPtr->algo_ptr);
esif_link_list_destroy(dspPtr->domain_ptr);
esif_link_list_destroy(dspPtr->cap_ptr);
esif_link_list_destroy(dspPtr->evt_ptr);
esif_ccb_free(dspPtr);
}
/* CPC Free */
void esif_cpc_free(struct esif_lp_dsp *dsp_ptr)
{
ESIF_TRACE_DYN_CPC("%s: START\n", ESIF_FUNC);
if (NULL == dsp_ptr || NULL == dsp_ptr->cpc_ptr)
return;
esif_ccb_free(dsp_ptr->cpc_ptr);
dsp_ptr->cpc_ptr = NULL;
ESIF_TRACE_DYN_CPC("%s: STOP\n", ESIF_FUNC);
}
