// 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;
}
// backwards compatibility
eEsifError EsifConfigSet(
EsifDataPtr nameSpace,
EsifDataPtr path,
esif_flags_t flags,
EsifDataPtr value
)
{
eEsifError rc = ESIF_OK;
// Get the NameSpace or create it if it does not exist
DataVaultPtr DB = DataBank_GetNameSpace(g_DataBankMgr, (StringPtr)(nameSpace->buf_ptr));
if (!DB) {
struct esif_ccb_file dv_file = {0};
DB = DataBank_OpenNameSpace(g_DataBankMgr, (StringPtr)nameSpace->buf_ptr);
if (!DB) {
return ESIF_E_NOT_FOUND;
}
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");
rc = DataVault_ReadVault(DB);
if (rc == ESIF_E_NOT_FOUND) {
rc = ESIF_OK;
}
}
if (rc == ESIF_OK) {
esif_ccb_write_lock(&DB->lock);
rc = DataVault_SetValue(DB, path, value, flags);
esif_ccb_write_unlock(&DB->lock);
}
return rc;
}
/* Start Conjure Library */
eEsifError EsifConjureStart(EsifCnjPtr conjurePtr)
{
eEsifError rc = ESIF_OK;
GetIfaceFuncPtr iface_func_ptr = NULL;
EsifString iface_func_name = "GetConjureInterface";
char libPath[ESIF_LIBPATH_LEN];
ESIF_TRACE_DEBUG("%s name=%s\n", ESIF_FUNC, conjurePtr->fLibNamePtr);
esif_build_path(libPath, ESIF_LIBPATH_LEN, ESIF_PATHTYPE_DLL, conjurePtr->fLibNamePtr, ESIF_LIB_EXT);
conjurePtr->fLibHandle = esif_ccb_library_load(libPath);
if (NULL == conjurePtr->fLibHandle) {
rc = ESIF_E_UNSPECIFIED;
ESIF_TRACE_ERROR("%s esif_ccb_library_load() %s failed.\n", ESIF_FUNC, libPath);
goto exit;
}
ESIF_TRACE_DEBUG("%s esif_ccb_library_load() %s completed.\n", ESIF_FUNC, libPath);
iface_func_ptr = (GetIfaceFuncPtr)esif_ccb_library_get_func(conjurePtr->fLibHandle, (EsifString)iface_func_name);
if (NULL == iface_func_ptr) {
rc = ESIF_E_UNSPECIFIED;
ESIF_TRACE_ERROR("%s esif_ccb_library_get_func() %s failed.\n", ESIF_FUNC, iface_func_name);
goto exit;
}
ESIF_TRACE_DEBUG("%s esif_ccb_library_get_func() %s completed.\n", ESIF_FUNC, iface_func_name);
rc = ConjureCreate(conjurePtr, iface_func_ptr);
ESIF_TRACE_DEBUG("%s ConjureCreate completed.\n", ESIF_FUNC);
exit:
return rc;
}
esif_string EsifLogFile_GetFullPath(esif_string buffer, size_t buf_len, const char *filename)
{
char *sep = strrchr((char *)filename, *ESIF_PATH_SEP);
if (sep != NULL)
filename = sep+1; // Ignore folders and use file.ext only
esif_build_path(buffer, buf_len, ESIF_PATHTYPE_LOG, (esif_string)filename, NULL);
return buffer;
}
eEsifError EsifAppStart(EsifAppPtr appPtr)
{
ESIF_TRACE_ENTRY_INFO();
eEsifError rc = ESIF_OK;
GetIfaceFuncPtr iface_func_ptr = NULL;
esif_string iface_func_name = GET_APPLICATION_INTERFACE_FUNCTION;
char libPath[ESIF_LIBPATH_LEN];
ESIF_TRACE_DEBUG("name=%s\n", appPtr->fLibNamePtr);
esif_build_path(libPath, ESIF_LIBPATH_LEN, ESIF_PATHTYPE_DLL, appPtr->fLibNamePtr, ESIF_LIB_EXT);
appPtr->fLibHandle = esif_ccb_library_load(libPath);
if (NULL == appPtr->fLibHandle || NULL == appPtr->fLibHandle->handle) {
rc = esif_ccb_library_error(appPtr->fLibHandle);
ESIF_TRACE_DEBUG("esif_ccb_library_load() %s failed [%s (%d)]: %s\n", libPath, esif_rc_str(rc), rc, esif_ccb_library_errormsg(appPtr->fLibHandle));
goto exit;
}
ESIF_TRACE_DEBUG("esif_ccb_library_load() %s completed.\n", libPath);
iface_func_ptr = (GetIfaceFuncPtr)esif_ccb_library_get_func(appPtr->fLibHandle, (char*)iface_func_name);
if (NULL == iface_func_ptr) {
rc = esif_ccb_library_error(appPtr->fLibHandle);
ESIF_TRACE_DEBUG("esif_ccb_library_get_func() %s failed [%s (%d)]: %s\n", iface_func_name, esif_rc_str(rc), rc, esif_ccb_library_errormsg(appPtr->fLibHandle));
goto exit;
}
ESIF_TRACE_DEBUG("esif_ccb_library_get_func() %s completed.\n", iface_func_name);
rc = AppCreate(appPtr, iface_func_ptr);
if (ESIF_OK != rc) {
ESIF_TRACE_DEBUG("AppCreate failed.\n");
goto exit;
}
ESIF_TRACE_DEBUG("AppCreate completed.\n");
rc = EsifApp_RegisterParticipantsWithApp(appPtr);
if (ESIF_OK != rc) {
ESIF_TRACE_DEBUG("EsifApp_RegisterParticipantsWithApp failed.\n");
goto exit;
}
ESIF_TRACE_DEBUG("EsifApp_RegisterParticipantsWithApp completed.\n");
exit:
if (ESIF_OK != rc) {
esif_ccb_library_unload(appPtr->fLibHandle);
appPtr->fLibHandle = NULL;
}
ESIF_TRACE_EXIT_INFO_W_STATUS(rc);
return rc;
}
//
// Write to Transaction Log - Used for debugging only
// NOTE: This version is just a dumb text log, not a recoverable transaction log
//
static void DataVault_WriteLog(
DataVaultPtr self,
esif_string action,
esif_string nameSpace,
EsifDataPtr path,
esif_flags_t flags,
EsifDataPtr value
)
{
#ifndef ESIF_CONFIG_LOG
UNREFERENCED_PARAMETER(self);
UNREFERENCED_PARAMETER(action);
UNREFERENCED_PARAMETER(nameSpace);
UNREFERENCED_PARAMETER(path);
UNREFERENCED_PARAMETER(flags);
UNREFERENCED_PARAMETER(value);
#else
struct esif_ccb_file log_file = {0};
FILE *filePtr = NULL;
time_t now;
char theTime[30];
UNREFERENCED_PARAMETER(self);
if (!flags) {
return;
}
esif_build_path(log_file.filename, sizeof(log_file.filename), ESIF_PATHTYPE_DV, nameSpace, ESIFDV_LOGFILEEXT);
filePtr = esif_ccb_fopen(log_file.filename, "ab", NULL);
if (NULL == filePtr) {
return;
}
time(&now);
esif_ccb_ctime(theTime, sizeof(theTime), &now);
esif_ccb_fprintf(filePtr, "%.24s: %-6s %s flags=%d",
theTime,
action,
(EsifString)path->buf_ptr,
flags);
if (NULL != value) {
UInt32 ch;
esif_ccb_fprintf(filePtr, " type=%d buf_len=%d data_len=%d buf_ptr=%s", value->type, value->buf_len, value->data_len, (value->buf_ptr ? "0x" : "NULL"));
for (ch = 0; NULL != value->buf_ptr && ch < value->data_len; ch++)
esif_ccb_fprintf(filePtr, "%02X", (int)((UInt8*)(value->buf_ptr))[ch]);
}
esif_ccb_fprintf(filePtr, "\r\n");
fclose(filePtr);
#endif
}
/* Data For Interface Marshaling */
static AppDataPtr CreateAppData(esif_string pathBuf)
{
AppDataPtr app_data_ptr = NULL;
char policyPath[ESIF_PATH_LEN] = { 0 };
if (NULL == pathBuf) {
ESIF_TRACE_ERROR("Path buffer is NULL\n");
goto exit;
}
/* Build path(s) for DPTF: "HomeDir" or "HomeDir|[#]PolicyDir" */
esif_build_path(pathBuf, ESIF_PATH_LEN, ESIF_PATHTYPE_DPTF, NULL, NULL);
esif_build_path(policyPath, sizeof(policyPath), ESIF_PATHTYPE_DLL, NULL, NULL);
if (esif_ccb_strcmp(pathBuf, policyPath) != 0) {
char policyDummyPath[ESIF_PATH_LEN] = { 0 }; /* empty if path starts with "#" */
esif_build_path(policyDummyPath, sizeof(policyDummyPath), ESIF_PATHTYPE_DLL, "", NULL);
esif_ccb_sprintf_concat(ESIF_PATH_LEN, pathBuf, "|%s%s", (policyDummyPath[0] ? "" : "#"), policyPath);
}
ESIF_TRACE_DEBUG("pathBuf=%s\n\n", (esif_string)pathBuf);
app_data_ptr = (AppDataPtr)esif_ccb_malloc(sizeof(AppData));
if (NULL == app_data_ptr) {
ESIF_TRACE_ERROR("Fail to allocate AppData\n");
goto exit;
}
app_data_ptr->fPathHome.buf_ptr = (void *)pathBuf;
app_data_ptr->fPathHome.buf_len = ESIF_PATH_LEN;
app_data_ptr->fPathHome.data_len = (UInt32)esif_ccb_strlen(pathBuf, ESIF_PATH_LEN);
app_data_ptr->fPathHome.type = ESIF_DATA_STRING;
app_data_ptr->fLogLevel = (eLogType) g_traceLevel;
exit:
return app_data_ptr;
}
void esif_memtrace_exit()
{
struct memalloc_s *mem = NULL;
char tracefile[MAX_PATH] = {0};
FILE *tracelog = NULL;
esif_build_path(tracefile, sizeof(tracefile), ESIF_PATHTYPE_LOG, "memtrace.txt", NULL);
esif_pathlist_exit();
esif_ccb_write_lock(&g_memtrace.lock);
mem = g_memtrace.allocated;
g_memtrace.allocated = NULL;
esif_ccb_write_unlock(&g_memtrace.lock);
CMD_OUT("MemTrace: Allocs=" ATOMIC_FMT " Frees=" ATOMIC_FMT "\n", atomic_read(&g_memtrace.allocs), atomic_read(&g_memtrace.frees));
if (!mem) {
goto exit;
}
CMD_OUT("\n*** MEMORY LEAKS DETECTED ***\nFor details see %s\n", tracefile);
esif_ccb_fopen(&tracelog, tracefile, "a");
if (tracelog) {
time_t now = time(NULL);
char timestamp[MAX_CTIME_LEN] = {0};
esif_ccb_ctime(timestamp, sizeof(timestamp), &now);
fprintf(tracelog, "\n*** %.24s: MEMORY LEAKS DETECTED (%s) ***\n", timestamp, ESIF_UF_VERSION);
}
while (mem) {
struct memalloc_s *node = mem;
if (tracelog) {
fprintf(tracelog, "[%s @%s:%d]: (%lld bytes) %p\n", mem->func, mem->file, mem->line, (long long)mem->size, mem->mem_ptr);
}
mem = mem->next;
native_free(node->mem_ptr);
native_free(node);
}
if (tracelog) {
esif_ccb_fclose(tracelog);
}
exit:
esif_ccb_lock_uninit(&g_memtrace.lock);
}
static eEsifError EsifActMgr_CreatePossActList_Locked()
{
eEsifError rc = ESIF_OK;
struct esif_ccb_file curFile = {0};
esif_ccb_file_enum_t fileIter = {0};
char libPath[ESIF_LIBPATH_LEN];
char *dotPtr = NULL;
EsifActMgrEntryPtr newPossPtr = NULL;
EsifString filePattern = ESIF_UPE_FILE_PREFIX "*" ESIF_LIB_EXT;
g_actMgr.possibleActions = esif_link_list_create();
if (NULL == g_actMgr.possibleActions) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
/* Get the loadable action directory path */
esif_build_path(libPath, sizeof(libPath), ESIF_PATHTYPE_DLL, NULL, NULL);
fileIter = esif_ccb_file_enum_first(libPath, filePattern, &curFile);
if (INVALID_HANDLE_VALUE == fileIter) {
goto exit;
}
do {
newPossPtr = esif_ccb_malloc(sizeof(*newPossPtr));
if(NULL == newPossPtr) {
break;
}
dotPtr = esif_ccb_strchr(curFile.filename, '.');
if (dotPtr != NULL) {
*dotPtr = '\0';
newPossPtr->libName = (esif_string)esif_ccb_strdup(curFile.filename);
esif_link_list_add_at_back(g_actMgr.possibleActions, (void *)newPossPtr);
}
} while (esif_ccb_file_enum_next(fileIter, filePattern, &curFile));
esif_ccb_file_enum_close(fileIter);
exit:
return rc;
}
eEsifError EsifActStart (EsifActPtr actionPtr)
{
eEsifError rc = ESIF_OK;
GetIfaceFuncPtr iface_func_ptr = NULL;
EsifString iface_func_name = "GetActionInterface";
char libPath[ESIF_LIBPATH_LEN];
esif_lib_t lib_handle = 0;
ESIF_TRACE_DEBUG("%s name=%s\n", ESIF_FUNC, actionPtr->fLibNamePtr);
esif_ccb_sprintf(ESIF_LIBPATH_LEN, libPath, "%s.%s",
esif_build_path(libPath, ESIF_LIBPATH_LEN, ESIF_DIR_PRG, actionPtr->fLibNamePtr), ESIF_LIB_EXT);
lib_handle = esif_ccb_library_load(libPath);
if (0 == lib_handle) {
rc = ESIF_E_UNSPECIFIED;
ESIF_TRACE_DEBUG("%s esif_ccb_library_load() %s failed.\n", ESIF_FUNC, libPath);
goto exit;
}
ESIF_TRACE_DEBUG("%s esif_ccb_library_load() %s completed.\n", ESIF_FUNC, libPath);
iface_func_ptr = (GetIfaceFuncPtr)
esif_ccb_library_get_func(lib_handle, (EsifString)iface_func_name);
if (NULL == iface_func_ptr) {
rc = ESIF_E_UNSPECIFIED;
ESIF_TRACE_DEBUG("%s esif_ccb_library_get_func() %s failed.\n",
ESIF_FUNC, iface_func_name);
goto exit;
}
ESIF_TRACE_DEBUG("%s esif_ccb_library_get_func() %s completed.\n",
ESIF_FUNC, iface_func_name);
rc = ActionCreate(actionPtr, iface_func_ptr);
ESIF_TRACE_DEBUG("%s ActionCreate completed.\n", ESIF_FUNC);
exit:
return rc;
}
static eEsifError EsifActMgr_LoadAction(
EsifActMgrEntryPtr entryPtr,
GetIfaceFuncPtr *getIfacePtr
)
{
eEsifError rc = ESIF_OK;
GetIfaceFuncPtr ifaceFuncPtr = NULL;
EsifString ifaceFuncName = "GetActionInterface";
char libPath[ESIF_LIBPATH_LEN];
ESIF_ASSERT(entryPtr != NULL);
ESIF_ASSERT(getIfacePtr != NULL);
ESIF_TRACE_DEBUG("Name=%s\n", entryPtr->libName);
esif_build_path(libPath, sizeof(libPath), ESIF_PATHTYPE_DLL, entryPtr->libName, ESIF_LIB_EXT);
entryPtr->lib = esif_ccb_library_load(libPath);
if (NULL == entryPtr->lib || NULL == entryPtr->lib->handle) {
rc = esif_ccb_library_error(entryPtr->lib);
ESIF_TRACE_ERROR("esif_ccb_library_load() %s failed [%s (%d)]: %s\n", libPath, esif_rc_str(rc), rc, esif_ccb_library_errormsg(entryPtr->lib));
goto exit;
}
ESIF_TRACE_DEBUG("esif_ccb_library_load() %s completed.\n", libPath);
ifaceFuncPtr = (GetIfaceFuncPtr)esif_ccb_library_get_func(entryPtr->lib, (EsifString)ifaceFuncName);
if (NULL == ifaceFuncPtr) {
rc = esif_ccb_library_error(entryPtr->lib);
ESIF_TRACE_ERROR("esif_ccb_library_get_func() %s failed [%s (%d)]: %s\n", libPath, esif_rc_str(rc), rc, esif_ccb_library_errormsg(entryPtr->lib));
goto exit;
}
ESIF_TRACE_DEBUG("esif_ccb_library_get_func() %s completed.\n", ifaceFuncName);
*getIfacePtr = ifaceFuncPtr;
exit:
return rc;
}
static eEsifError esif_dsp_file_scan()
{
eEsifError rc = ESIF_OK;
struct esif_ccb_file *ffdPtr = NULL;
esif_ccb_file_enum_t findHandle = ESIF_INVALID_FILE_ENUM_HANDLE;
char path[MAX_PATH] = {0};
char pattern[MAX_PATH] = {0};
StringPtr namesp = ESIF_DSP_NAMESPACE;
DataVaultPtr DB = DataBank_GetDataVault(namesp);
// 1. Load all EDP's in the DSP Configuration Namespace, if any exist
if (DB) {
EsifDataPtr nameSpace = EsifData_CreateAs(ESIF_DATA_AUTO, namesp, 0, ESIFAUTOLEN);
EsifDataPtr key = EsifData_CreateAs(ESIF_DATA_AUTO, NULL, ESIF_DATA_ALLOCATE, 0);
EsifDataPtr value = EsifData_CreateAs(ESIF_DATA_AUTO, NULL, ESIF_DATA_ALLOCATE, 0);
EsifConfigFindContext context = NULL;
ESIF_TRACE_DEBUG("SCAN CONFIG For DSP Files NameSpace = %s, Pattern %s", namesp, pattern);
if (nameSpace != NULL && key != NULL && value != NULL &&
(rc = EsifConfigFindFirst(nameSpace, key, value, &context)) == ESIF_OK) {
do {
// Load all keys from the DataVault with an ".edp" extension
if (key->data_len >= 5 && esif_ccb_stricmp(((StringPtr)(key->buf_ptr)) + key->data_len - 5, ".edp") == 0) {
ffdPtr = (struct esif_ccb_file *)esif_ccb_malloc(sizeof(*ffdPtr));
esif_ccb_strcpy(ffdPtr->filename, (StringPtr)key->buf_ptr, sizeof(ffdPtr->filename));
if (esif_dsp_entry_create(ffdPtr) != ESIF_OK) {
esif_ccb_free(ffdPtr);
}
}
EsifData_Set(key, ESIF_DATA_AUTO, NULL, ESIF_DATA_ALLOCATE, 0);
EsifData_Set(value, ESIF_DATA_AUTO, NULL, ESIF_DATA_ALLOCATE, 0);
} while ((rc = EsifConfigFindNext(nameSpace, key, value, &context)) == ESIF_OK);
EsifConfigFindClose(&context);
if (rc == ESIF_E_ITERATION_DONE) {
rc = ESIF_OK;
}
}
EsifData_Destroy(nameSpace);
EsifData_Destroy(key);
EsifData_Destroy(value);
}
// 2. Load all EDP's from the DSP folder, if any exist, except ones already loaded from DataBank
esif_build_path(path, MAX_PATH, ESIF_PATHTYPE_DSP, NULL, NULL);
esif_ccb_strcpy(pattern, "*.edp", MAX_PATH);
ESIF_TRACE_DEBUG("SCAN File System For DSP Files Path = %s, Pattern %s", path, pattern);
/* Find the first file in the directory that matches are search */
ffdPtr = (struct esif_ccb_file *)esif_ccb_malloc(sizeof(*ffdPtr));
if (ffdPtr == NULL) {
ESIF_TRACE_ERROR("Fail to allocate esif_ccb file\n");
rc = ESIF_E_NO_MEMORY;
goto exit;
}
findHandle = esif_ccb_file_enum_first(path, pattern, ffdPtr);
if (ESIF_INVALID_FILE_ENUM_HANDLE == findHandle) {
rc = ESIF_E_UNSPECIFIED;
goto exit;
}
/* Process Each File */
do {
// Don't process the file if it the same name was already loaded from a DataVault
if (DB == NULL || DataCache_GetValue(DB->cache, ffdPtr->filename) == NULL) {
if (esif_dsp_entry_create(ffdPtr) != ESIF_OK) {
esif_ccb_free(ffdPtr);
}
ffdPtr = (struct esif_ccb_file *)esif_ccb_malloc(sizeof(*ffdPtr));
}
} while (esif_ccb_file_enum_next(findHandle, pattern, ffdPtr));
esif_ccb_file_enum_close(findHandle);
exit:
if (ffdPtr != NULL) {
esif_ccb_free(ffdPtr);
}
return rc;
}
/* Add DSP Entry */
static eEsifError esif_dsp_entry_create(struct esif_ccb_file *file_ptr)
{
eEsifError rc = ESIF_E_UNSPECIFIED;
EsifDspPtr dspPtr = NULL;
EsifFpcPtr fpcPtr = NULL;
UInt32 fpcIsStatic = ESIF_FALSE;
UInt8 i = 0;
char path[MAX_PATH]={0};
UInt32 fpcSize = 0;
UInt32 edpSize = 0;
size_t numFpcBytesRead = 0;
struct edp_dir edp_dir;
EsifDataPtr nameSpace = 0;
EsifDataPtr key = 0;
EsifDataPtr value = 0;
IOStreamPtr ioPtr = IOStream_Create();
if ((NULL == file_ptr) || (NULL == ioPtr)) {
ESIF_TRACE_ERROR("The file pointer or IO stream is NULL\n");
goto exit;
}
nameSpace = EsifData_CreateAs(ESIF_DATA_STRING, ESIF_DSP_NAMESPACE, 0, ESIFAUTOLEN);
key = EsifData_CreateAs(ESIF_DATA_STRING, file_ptr->filename, 0, ESIFAUTOLEN);
value = EsifData_CreateAs(ESIF_DATA_AUTO, NULL, ESIF_DATA_ALLOCATE, 0);
if (nameSpace == NULL || key == NULL || value == NULL) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
ESIF_TRACE_DEBUG("Filename: %s", file_ptr->filename);
dspPtr = esif_dsp_create();
if (NULL == dspPtr) {
ESIF_TRACE_ERROR("Fail to allocate dsp entry\n");
goto exit;
}
// Look for EDP file on disk first then in DataVault (static or file)
esif_build_path(path, sizeof(path), ESIF_PATHTYPE_DSP, file_ptr->filename, NULL);
if (!esif_ccb_file_exists(path) && EsifConfigGet(nameSpace, key, value) == ESIF_OK) {
esif_ccb_strcpy(path, file_ptr->filename, MAX_PATH);
IOStream_SetMemory(ioPtr, StoreReadOnly, (BytePtr)value->buf_ptr, value->data_len);
} else {
IOStream_SetFile(ioPtr, StoreReadOnly, path, "rb");
}
ESIF_TRACE_DEBUG("Fullpath: %s", path);
if (IOStream_Open(ioPtr) != 0) {
ESIF_TRACE_ERROR("File not found (%s)", path);
goto exit;
}
/* Read FPC From EDP File */
if (esif_ccb_strstr(&path[0], ".edp")) {
/* EDP - Only Read The FPC Part */
edpSize = (UInt32)IOStream_GetSize(ioPtr);
if (!edpSize) {
goto exit;
}
numFpcBytesRead = IOStream_Read(ioPtr, &edp_dir, sizeof(edp_dir));
if (!esif_verify_edp(&edp_dir, numFpcBytesRead)) {
ESIF_TRACE_ERROR("Invalid EDP Header: Signature=%4.4s Version=%d\n", (char *)&edp_dir.signature, edp_dir.version);
goto exit;
}
if (edpSize > MAX_EDP_SIZE || edp_dir.fpc_offset > MAX_FPC_SIZE || edp_dir.fpc_offset > edpSize) {
ESIF_TRACE_ERROR("The edp or fpc file size is larger than maximum\n");
goto exit;
}
fpcSize = edpSize - edp_dir.fpc_offset;
IOStream_Seek(ioPtr, edp_dir.fpc_offset, SEEK_SET);
ESIF_TRACE_DEBUG("File found (%s) size %u, FPC size %u from offset %u", path, edpSize, fpcSize, edp_dir.fpc_offset);
} else {
ESIF_TRACE_DEBUG("File %s does not have .fpc and .edp format!", path);
}
// use static DataVault buffer (if available), otherwise allocate space for our FPC file contents (which will not be freed)
if (IOStream_GetType(ioPtr) == StreamMemory && value->buf_len == 0) {
fpcPtr = (EsifFpcPtr)IOStream_GetMemoryBuffer(ioPtr);
if (NULL == fpcPtr) {
ESIF_TRACE_ERROR("NULL buffer");
goto exit;
}
fpcPtr = (EsifFpcPtr) (((BytePtr) fpcPtr) + IOStream_GetOffset(ioPtr));
numFpcBytesRead = fpcSize;
ESIF_TRACE_DEBUG("Static vault size %u buf_ptr=0x%p\n", (int)numFpcBytesRead, fpcPtr);
fpcIsStatic = ESIF_TRUE;
} else {
fpcPtr = (EsifFpcPtr)esif_ccb_malloc(fpcSize);
if (NULL == fpcPtr) {
ESIF_TRACE_ERROR("malloc failed to allocate %u bytes\n", fpcSize);
goto exit;
}
ESIF_TRACE_DEBUG("File malloc size %u", fpcSize);
// read file contents
numFpcBytesRead = IOStream_Read(ioPtr, fpcPtr, fpcSize);
if (numFpcBytesRead < fpcSize) {
ESIF_TRACE_ERROR("Read short received %u of %u bytes\n", (int)numFpcBytesRead, fpcSize);
goto exit;
}
ESIF_TRACE_DEBUG("File read size %u", (int)numFpcBytesRead);
}
ESIF_TRACE_DEBUG("\nDecode Length: %u", fpcPtr->size);
ESIF_TRACE_DEBUG("Code: %s", fpcPtr->header.code);
ESIF_TRACE_DEBUG("Ver Major: %u", fpcPtr->header.ver_major);
ESIF_TRACE_DEBUG("Ver Minor: %u", fpcPtr->header.ver_minor);
ESIF_TRACE_DEBUG("Name: %s", fpcPtr->header.name);
ESIF_TRACE_DEBUG("Description: %s", fpcPtr->header.description);
ESIF_TRACE_DEBUG("Type: %s", fpcPtr->header.type);
ESIF_TRACE_DEBUG("Bus Enumerator: %u", fpcPtr->header.bus_enum);
ESIF_TRACE_DEBUG("ACPI Device: %s", fpcPtr->header.acpi_device);
ESIF_TRACE_DEBUG("ACPI Scope: %s", fpcPtr->header.acpi_scope);
ESIF_TRACE_DEBUG("ACPI Type: %s", fpcPtr->header.acpi_type);
ESIF_TRACE_DEBUG("ACPI UID: %s", fpcPtr->header.acpi_UID);
ESIF_TRACE_DEBUG("PCI Vendor ID: %s", fpcPtr->header.pci_vendor_id);
ESIF_TRACE_DEBUG("PCI Device ID: %s", fpcPtr->header.pci_device_id);
ESIF_TRACE_DEBUG("PCI Bus: %s", fpcPtr->header.pci_bus);
ESIF_TRACE_DEBUG("PCI Device: %s", fpcPtr->header.pci_device);
ESIF_TRACE_DEBUG("PCI Function: %s", fpcPtr->header.pci_function);
dspPtr->code_ptr = (EsifString)fpcPtr->header.name;
dspPtr->bus_enum = (UInt8 *)&fpcPtr->header.bus_enum;
dspPtr->type = (EsifString)fpcPtr->header.type;
dspPtr->ver_major_ptr = (UInt8 *)&fpcPtr->header.ver_major;
dspPtr->ver_minor_ptr = (UInt8 *)&fpcPtr->header.ver_minor;
dspPtr->acpi_device = (EsifString)fpcPtr->header.acpi_device;
dspPtr->acpi_scope = (EsifString)fpcPtr->header.acpi_scope;
dspPtr->acpi_type = (EsifString)fpcPtr->header.acpi_type;
dspPtr->acpi_uid = (EsifString)fpcPtr->header.acpi_UID;
dspPtr->vendor_id = (EsifString)fpcPtr->header.pci_vendor_id;
dspPtr->device_id = (EsifString)fpcPtr->header.pci_device_id;
dspPtr->pci_bus = (EsifString)&fpcPtr->header.pci_bus;
dspPtr->pci_bus_device = (EsifString)&fpcPtr->header.pci_device;
dspPtr->pci_function = (EsifString)&fpcPtr->header.pci_function;
/* Assign Function Pointers */
dspPtr->get_code = get_code;
dspPtr->get_ver_minor = get_ver_minor;
dspPtr->get_ver_major = get_ver_major;
dspPtr->get_temp_tc1 = get_temp_c1;
dspPtr->get_percent_xform = get_percent_xform;
dspPtr->insert_primitive = insert_primitive;
dspPtr->insert_algorithm = insert_algorithm;
dspPtr->insert_domain = insert_domain;
dspPtr->insert_event = insert_event;
dspPtr->get_primitive = get_primitive;
dspPtr->get_action = get_action;
dspPtr->get_algorithm = get_algorithm;
dspPtr->get_domain = get_domain;
dspPtr->get_event_by_type = get_event_by_type;
dspPtr->get_event_by_guid = get_event_by_guid;
dspPtr->init_fpc_iterator = init_fpc_iterator;
dspPtr->get_next_fpc_domain = get_next_fpc_domain;
dspPtr->get_domain_count = get_domain_count;
rc = esif_fpc_load(fpcPtr, dspPtr);
if (ESIF_OK == rc) {
ESIF_TRACE_DEBUG("FPC %s load successfully", path);
} else {
ESIF_TRACE_DEBUG("Unable to load FPC %s, rc %s", path, esif_rc_str(rc));
goto exit;
}
/* Lock DSP Manager */
esif_ccb_write_lock(&g_dm.lock);
/* Simple Table Lookup For Now. Scan Table And Find First Empty Slot */
/* Empty slot indicated by AVAILABLE state */
for (i = 0; i < MAX_DSP_MANAGER_ENTRY; i++) {
if (NULL == g_dm.dme[i].dsp_ptr) {
break;
}
}
/* If No Available Slots Return */
if (i >= MAX_DSP_MANAGER_ENTRY) {
esif_ccb_write_unlock(&g_dm.lock);
ESIF_TRACE_ERROR("No free dsp manager entry is available for %s\n", file_ptr->filename);
goto exit;
}
/*
** Take Slot
*/
g_dm.dme[i].dsp_ptr = dspPtr;
g_dm.dme[i].file_ptr = file_ptr;
g_dm.dme[i].fpc_ptr = (fpcIsStatic ? 0 : fpcPtr);
g_dm.dme_count++;
dspPtr = NULL; // Prevent deallocate on exit
fpcPtr = NULL; // Prevent deallocate on exit
esif_ccb_write_unlock(&g_dm.lock);
rc = ESIF_OK;
ESIF_TRACE_INFO("Create entry in dsp manager successfully for %s\n", file_ptr->filename);
exit:
IOStream_Destroy(ioPtr);
EsifData_Destroy(nameSpace);
EsifData_Destroy(key);
EsifData_Destroy(value);
esif_dsp_destroy(dspPtr);
if (!fpcIsStatic) {
esif_ccb_free(fpcPtr);
}
return rc;
}
static int esif_ws_http_process_static_pages (
ClientRecordPtr connection,
char *buffer,
char *resource,
ssize_t ret,
char *fileType
)
{
struct stat st={0};
char tmpbuffer[128]={0};
char file_to_open[MAX_PATH]={0};
char content_disposition[MAX_PATH]={0};
FILE *file_fp = NULL;
esif_build_path(file_to_open, sizeof(file_to_open), ESIF_PATHTYPE_UI, resource, NULL);
esif_ccb_fopen(&file_fp, (esif_string)file_to_open, (esif_string)"rb");
// Log file workaround: If not found in HTML folder, look in LOG folder
if (NULL == file_fp) {
char logpath[MAX_PATH]={0};
esif_build_path(logpath, sizeof(logpath), ESIF_PATHTYPE_LOG, resource, NULL);
esif_ccb_fopen(&file_fp, (esif_string)logpath, (esif_string)"rb");
if (NULL != file_fp)
esif_ccb_strcpy(file_to_open, logpath, sizeof(file_to_open));
}
ESIF_TRACE_DEBUG("HTTP: file=%s, type=%s\n", file_to_open, fileType);
if (NULL == file_fp) {
ESIF_TRACE_DEBUG("failed to open file: %s\n", file_to_open);
return 404;
}
if (esif_ccb_stat(file_to_open, &st) != 0) {
ESIF_TRACE_DEBUG("Could not stat file descriptor \n");
fclose(file_fp);
return 404;
}
fseek(file_fp, (off_t)0, SEEK_END);
fseek(file_fp, (off_t)0, SEEK_SET);
// Add Content-Disposition header to prompt user with Save-As Dialog if unknown file type
if (esif_ccb_strcmp(fileType, UNKNOWN_MIME_TYPE) == 0) {
esif_ccb_sprintf(sizeof(content_disposition), content_disposition, "Content-Disposition: attachment; filename=\"%s\";\n", resource);
}
esif_ccb_sprintf(WS_BUFFER_LENGTH, buffer,
"HTTP/1.1 200 OK\n"
"Server: ESIF_UF/%s\n"
"Last-Modified: %s\n"
"Date: %s\n"
"Content-Type: %s\n"
"Content-Length: %ld\n"
"%s"
"Connection: close\n"
"\n",
ESIF_UF_VERSION,
esif_ws_http_time_stamp(st.st_mtime, tmpbuffer),
esif_ws_http_time_stamp(time(0), tmpbuffer),
fileType,
(long)st.st_size,
content_disposition);
send(connection->socket, buffer, (int)esif_ccb_strlen(buffer, WS_BUFFER_LENGTH), ESIF_WS_SEND_FLAGS);
while ((ret = (int)fread(buffer, 1, WS_BUFFER_LENGTH, file_fp)) > 0) {
send(connection->socket, buffer, (int)ret, ESIF_WS_SEND_FLAGS);
}
fclose(file_fp);
return 0;
}
