// 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; }
static eEsifError EsifGetActionDelegateCnfg( const EsifUpDomainPtr domainPtr, const EsifDataPtr requestPtr, EsifDataPtr responsePtr ) { extern int g_shell_enabled; // ESIF Shell Enabled Flag extern Bool g_ws_restricted;// Web Server Restricted Mode Flag eEsifError rc = ESIF_OK; EsifPrimitiveTuple dcfgTuple = { GET_CONFIG_ACCESS_CONTROL_SUR, 0, 255 }; EsifPrimitiveTuple gddvTuple = { GET_CONFIG_DATAVAULT_SUR, 0, 255 }; EsifData dcfgData = { ESIF_DATA_UINT32, NULL, ESIF_DATA_ALLOCATE, 0 }; EsifData gddvData = { ESIF_DATA_AUTO, NULL, ESIF_DATA_ALLOCATE, 0 }; ESIF_ASSERT(NULL != domainPtr); ESIF_ASSERT(NULL != requestPtr); UNREFERENCED_PARAMETER(responsePtr); // Not currently used by DPTF dcfgTuple.domain = domainPtr->domain; gddvTuple.domain = domainPtr->domain; // Execute DCFG to read Access Control List Bitmask from BIOS, if it exists rc = EsifUp_ExecutePrimitive(domainPtr->upPtr, &dcfgTuple, requestPtr, &dcfgData); if (rc == ESIF_OK && dcfgData.buf_ptr != NULL && dcfgData.buf_len >= sizeof(UInt32)) { DCfgOptions newmask = { .asU32 = *(UInt32 *)dcfgData.buf_ptr }; DCfg_Set(newmask); ESIF_TRACE_INFO("DCFG Loaded: 0x%08X\n", newmask.asU32); // Disable ESIF Shell if Access Control forbids it if (DCfg_Get().opt.ShellAccessControl) { g_shell_enabled = 0; } // Stop Web Server (if Started) if Restricted or Generic Access Control forbids it if (EsifWebIsStarted() && ((!g_ws_restricted && DCfg_Get().opt.GenericUIAccessControl)|| (g_ws_restricted && DCfg_Get().opt.RestrictedUIAccessControl)) ) { EsifWebStop(); } } // Execute GDDV to read DataVault from BIOS, if it exists rc = EsifUp_ExecutePrimitive(domainPtr->upPtr, &gddvTuple, requestPtr, &gddvData); if (rc != ESIF_OK) { // Always Return OK if no ESIF_LF or GDDV object in BIOS if (rc == ESIF_E_NO_LOWER_FRAMEWORK || rc == ESIF_E_ACPI_OBJECT_NOT_FOUND) { rc = ESIF_OK; } } else { char *dv_name = "__merge"; // Temporary DV Name DataVaultPtr DB = DataBank_GetNameSpace(g_DataBankMgr, dv_name); if (DB != NULL) { DataBank_CloseNameSpace(g_DataBankMgr, dv_name); } DB = DataBank_OpenNameSpace(g_DataBankMgr, dv_name); // Load Datavault into temporary namespace. DV may or may not be preceded by a variant if (DB) { u32 skipbytes = 0; void *buffer = NULL; // // This is in place to resolve a static code analysis issue. // This should never happen if EsifUp_ExecutePrimitive is successful above. // if (NULL == gddvData.buf_ptr) { DataBank_CloseNameSpace(g_DataBankMgr, dv_name); ESIF_TRACE_DEBUG("No data returned for BIOS datavault.\n"); goto exit; } skipbytes = (memcmp(gddvData.buf_ptr, "\xE5\x1F", 2) == 0 ? 0 : sizeof(union esif_data_variant)); buffer = esif_ccb_malloc(gddvData.data_len); if (NULL == buffer) { DataBank_CloseNameSpace(g_DataBankMgr, dv_name); ESIF_TRACE_DEBUG("Unable to allocate memory\n"); rc = ESIF_E_NO_MEMORY; goto exit; } esif_ccb_memcpy(buffer, (u8*)gddvData.buf_ptr + skipbytes, gddvData.data_len - skipbytes); IOStream_SetMemory(DB->stream, buffer, gddvData.data_len - skipbytes); if ((rc = DataVault_ReadVault(DB)) != ESIF_OK) { DataBank_CloseNameSpace(g_DataBankMgr, dv_name); ESIF_TRACE_DEBUG("Unable to Open DataVault: %s\n", esif_rc_str(rc)); rc = ESIF_OK; } else { EsifDataPtr data_nspace = NULL; EsifDataPtr data_key = NULL; EsifDataPtr data_targetdv = NULL; esif_flags_t options = 0; // NOPERSIST esif_string keyspec = "*"; // Merge All Keys esif_string targetdv = g_DataVaultDefault; DB->flags |= (ESIF_SERVICE_CONFIG_READONLY); // Merge Contents into Default DataVault data_nspace = EsifData_CreateAs(ESIF_DATA_STRING, dv_name, 0, ESIFAUTOLEN); data_targetdv = EsifData_CreateAs(ESIF_DATA_STRING, targetdv, 0, ESIFAUTOLEN); data_key = EsifData_CreateAs(ESIF_DATA_STRING, keyspec, 0, ESIFAUTOLEN); if (data_nspace == NULL || data_key == NULL || data_targetdv == NULL) { rc = ESIF_E_NO_MEMORY; } else { rc = EsifConfigCopy(data_nspace, data_targetdv, data_key, options, ESIF_FALSE, NULL); } ESIF_TRACE_INFO("GDDV Loaded: %d bytes, %d keys => %s.dv [%s]\n", (int)IOStream_GetSize(DB->stream), DataCache_GetCount(DB->cache), targetdv, esif_rc_str(rc)); EsifData_Destroy(data_nspace); EsifData_Destroy(data_key); EsifData_Destroy(data_targetdv); DataBank_CloseNameSpace(g_DataBankMgr, dv_name); } esif_ccb_free(buffer); } } exit: esif_ccb_free(dcfgData.buf_ptr); esif_ccb_free(gddvData.buf_ptr); return rc; }
// 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; esif_string file_path = 0; char file_pattern[MAX_PATH]; char file_path_buf[MAX_PATH] = {0}; struct esif_ccb_file *ffd_ptr; UInt32 idx; ASSERT(self); esif_ccb_lock_init(&self->lock); // TODO: Locking // 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 ESIFDV_DIR if it doesn't exit (only 1 level deep for now) esif_ccb_makepath(ESIFDV_DIR); // Import all matching *.dv files into ReadWrite DataVaults esif_ccb_strcpy(file_path_buf, ESIFDV_DIR, sizeof(file_path_buf)); file_path = file_path_buf; 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) { return ESIF_E_NO_MEMORY; } find_handle = esif_ccb_file_enum_first(file_path, file_pattern, ffd_ptr); if (INVALID_HANDLE_VALUE == find_handle) { rc = ESIF_OK; // No Persisted DataVaults found } else { 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_ccb_sprintf(MAX_PATH, dv_file.filename, "%s%s%s", file_path, 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; }