// 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; }
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; }
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; }
// 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; }