static eEsifError DataVault_ReadPayload(DataVaultPtr self) { eEsifError rc = ESIF_OK; IOStreamPtr streamPtr = NULL; int vrc = EPERM; size_t fileOffset = 0; size_t curFileOffset = 0; size_t pairSize = 0; esif_flags_t item_flags = 0; EsifData key = { ESIF_DATA_STRING }; EsifData value = { ESIF_DATA_VOID }; ESIF_ASSERT(self != NULL); streamPtr = self->stream; // Open File or Memory Block if ((vrc = IOStream_Open(streamPtr)) != 0) { if (vrc == ENOENT) { rc = ESIF_E_NOT_FOUND; } else { rc = ESIF_E_IO_OPEN_FAILED; } goto exit; } // Move the file pointer to start of data fileOffset = sizeof(DataVaultHeader); if (IOStream_Seek(streamPtr, fileOffset, SEEK_SET) != EOK) { rc = ESIF_E_IO_ERROR; goto exit; } // Read Data and add to DataVault while (rc == ESIF_OK) { EsifData_ctor(&key); EsifData_ctor(&value); item_flags = 0; rc = DataVault_ReadNextKeyValuePair(self, &item_flags, &key, &value); if (rc != ESIF_OK) { if (ESIF_E_ITERATION_DONE == rc) { rc = ESIF_OK; } break; } // Validate that the data read is from within the region specified by the header curFileOffset = IOStream_GetOffset(streamPtr); pairSize = curFileOffset - fileOffset; fileOffset = curFileOffset; // Add value (including allocated buf_ptr) to cache DataCache_InsertValue(self->cache, (esif_string)key.buf_ptr, &value, item_flags); EsifData_dtor(&key); EsifData_dtor(&value); } exit: IOStream_Close(streamPtr); EsifData_dtor(&key); EsifData_dtor(&value); return rc; }
// Read DataVault from Disk eEsifError DataVault_ReadVault (DataVaultPtr self) { eEsifError rc = ESIF_E_UNSPECIFIED; // TODO int vrc = EPERM; DataVaultHeader header; UInt32 min_version; UInt32 max_version; esif_flags_t item_flags; IOStreamPtr vault = self->stream; // TODO: Locking // Open File or Memory Block if ((vrc = IOStream_Open(vault)) != 0) { if (vrc == ENOENT) { rc = ESIF_E_NOT_FOUND; } return rc; } // Read and Verify File Header // The DataVault's Major.Minor Version must be <= the App's Major.Minor Version and at least Major.0 memset(&header, 0, sizeof(header)); IOStream_Read(vault, &header, 4); // E51F#### where #### is header size, including this IOStream_Read(vault, ((UInt8*)&header) + 4, esif_ccb_min(header.headersize, sizeof(header)) - 4); min_version = ESIFDV_VERSION(ESIFDV_MAJOR_VERSION, 0, 0); max_version = ESIFDV_VERSION(ESIFDV_MAJOR_VERSION, ESIFDV_MINOR_VERSION, ESIFDV_MAX_REVISION); if (memcmp(header.signature, ESIFDV_SIGNATURE, sizeof(header.signature)) != 0 || header.version > max_version || header.version < min_version) { IOStream_Close(vault); return ESIF_E_NOT_SUPPORTED; } if (header.headersize > sizeof(header)) { IOStream_Seek(vault, header.headersize - sizeof(header), SEEK_CUR); } self->flags = header.flags; if (IOStream_GetType(vault) == StreamMemory) { self->flags |= ESIF_SERVICE_CONFIG_STATIC; } rc = ESIF_OK; // Read Data and add to DataVault while (IOStream_Read(vault, &item_flags, sizeof(item_flags)) == sizeof(item_flags)) { EsifData key; EsifData value; // Read Key EsifData_ctor(&key); EsifData_ctor(&value); key.type = ESIF_DATA_STRING; IOStream_Read(vault, &key.data_len, sizeof(key.data_len)); if (key.data_len > MAX_DV_DATALEN) { rc = ESIF_E_PARAMETER_IS_OUT_OF_BOUNDS; break; } switch (IOStream_GetType(vault)) { case StreamMemory: key.buf_len = 0; key.buf_ptr = IOStream_GetMemoryBuffer(vault) + IOStream_GetOffset(vault); IOStream_Seek(vault, key.data_len, SEEK_CUR); item_flags &= ~ESIF_SERVICE_CONFIG_NOCACHE; // ignore for Memory Vaults break; case StreamFile: default: key.buf_len = key.data_len; key.buf_ptr = esif_ccb_malloc(key.buf_len); if (!key.buf_ptr) { rc = ESIF_E_NO_MEMORY; break; } IOStream_Read(vault, key.buf_ptr, key.data_len); ((esif_string)(key.buf_ptr))[key.data_len - 1] = 0; break; } if (rc != ESIF_OK) { EsifData_dtor(&key); break; } // Read Value IOStream_Read(vault, &value.type, sizeof(value.type)); IOStream_Read(vault, &value.data_len, sizeof(value.data_len)); if (value.data_len > MAX_DV_DATALEN) { EsifData_dtor(&key); break; } // If NOCACHE mode, use buf_ptr to store the file offset of the data and skip the file if (item_flags & ESIF_SERVICE_CONFIG_NOCACHE) { size_t offset = IOStream_GetOffset(vault); IOStream_Seek(vault, value.data_len, SEEK_CUR); value.buf_ptr = (void*)offset; value.buf_len = 0; // data_len = original length } else { // Use static pointer for static data vaults (unless encrypted), otherwise make a dynamic copy if (IOStream_GetType(vault) == StreamMemory && !(item_flags & ESIF_SERVICE_CONFIG_ENCRYPT)) { value.buf_len = 0; // static value.buf_ptr = IOStream_GetMemoryBuffer(vault) + IOStream_GetOffset(vault); IOStream_Seek(vault, value.data_len, SEEK_CUR); } else { value.buf_len = value.data_len; // dynamic value.buf_ptr = esif_ccb_malloc(value.buf_len); if (!value.buf_ptr) { EsifData_dtor(&key); rc = ESIF_E_NO_MEMORY; break; } IOStream_Read(vault, value.buf_ptr, value.data_len); } // Decrypt Encrypted Data? if (item_flags & ESIF_SERVICE_CONFIG_ENCRYPT) { UInt32 byte; for (byte = 0; byte < value.data_len; byte++) ((UInt8*)(value.buf_ptr))[byte] = ~((UInt8*)(value.buf_ptr))[byte]; } } // Add value (including allocated buf_ptr) to cache DataCache_SetValue(self->cache, (esif_string)key.buf_ptr, value, item_flags); value.buf_ptr = 0; item_flags = 0; EsifData_dtor(&key); EsifData_dtor(&value); } IOStream_Close(vault); return rc; }