Beispiel #1
0
// Read DataVault from Disk
eEsifError DataVault_ReadVault(DataVaultPtr self)
{
	eEsifError rc = ESIF_OK;
	IOStreamPtr memStreamPtr = NULL;
	IOStreamPtr orgStreamPtr = NULL;
	DataVaultHeader header = {0};
	UInt32 hdrSize = 0;
	UInt32 min_version = 0;
	UInt32 max_version = 0;

	orgStreamPtr = self->stream;

	// Read the file into a memory stream for faster accesses (hash, size, etc.)
	rc = IOStream_CloneAsMemoryStream(self->stream, &memStreamPtr);
	if (rc != ESIF_OK) {
		goto exit;
	}

	self->stream = memStreamPtr;

	// Read in the header
	rc = DataVault_ReadHeader(self, &header);
	if (rc != ESIF_OK) {
		goto exit;
	}

	hdrSize = header.headersize;
	if (hdrSize < sizeof(header)) {
		rc = ESIF_E_NOT_SUPPORTED;
		goto exit;
	}

	// Verify signature
	if (memcmp(header.signature, ESIFDV_SIGNATURE, sizeof(header.signature)) != 0) {
		rc = ESIF_E_NOT_SUPPORTED;
		goto exit;
	}

	// The DataVault's Major.Minor Version must be <= the App's Major.Minor Version and at least Major.1
	min_version = ESIFDV_VERSION(ESIFDV_MAJOR_VERSION_MIN, 0, 0);
	max_version = ESIFDV_VERSION(ESIFDV_MAJOR_VERSION, ESIFDV_MINOR_VERSION, ESIFDV_MAX_REVISION);
	if ((header.version > max_version) || (header.version < min_version)) {
		rc = ESIF_E_NOT_SUPPORTED;
		goto exit;
	}

	// Save the header flags and version
	self->flags = header.flags;
	self->version = header.version;

	rc = DataVault_ReadPayload(self);

exit:
	IOStream_Close(self->stream);
	self->stream = orgStreamPtr; // Restore the original stream
	//esif_ccb_free(dataHdrsPtr);
	IOStream_Destroy(memStreamPtr);
	return rc;
}
Beispiel #2
0
// 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;
}
Beispiel #3
0
// Write DataVault to Disk
eEsifError DataVault_WriteVault(DataVaultPtr self)
{
	eEsifError rc = ESIF_OK;
	DataCacheEntryPtr pairPtr = NULL;
	IOStreamPtr diskStreamPtr = NULL;
	IOStreamPtr memStreamPtr = NULL;
	BytePtr memStreamBuffer = NULL;
	size_t memStreamBufSize = 0;
	UInt32 idx;
	DataCachePtr cacheClonePtr = NULL;

	if (FLAGS_TEST(self->flags, ESIF_SERVICE_CONFIG_STATIC | ESIF_SERVICE_CONFIG_READONLY)) {
		rc = ESIF_E_READONLY;
		goto exit;
	}

	if (self->stream->file.name == NULL || self->cache == NULL) {
		rc = ESIF_E_PARAMETER_IS_NULL;
		goto exit;
	}

	//
	// As the cache data can be modified while writing the data vault (due to
	// non-cached values), we create a clone of the current cache so that we can
	// fall back to it in case of a failure.
	//
	cacheClonePtr = DataCache_Clone(self->cache);
	if ((NULL == cacheClonePtr) && (self->cache != NULL)) {
		rc = ESIF_E_NO_MEMORY;
		goto exit;
	}

	//
	// Use a memory stream for creation before writing the final output to a file
	//
	memStreamPtr = IOStream_Create();
	if (!memStreamPtr) {
		rc = ESIF_E_NO_MEMORY;
		goto exit;
	}
	
	if (IOStream_SetMemory(memStreamPtr, NULL, 0) != EOK) {
		rc = ESIF_E_NO_MEMORY;
		goto exit;
	}

	//
	// If any rows contain NOCACHE PERSIST values, we need to read them from the
	// original file before we overwrite it
	//
	diskStreamPtr = IOStream_Create();
	if (diskStreamPtr == NULL) {
		rc = ESIF_E_NO_MEMORY;
		goto exit;
	}

	if (IOStream_Seek(memStreamPtr, sizeof(DataVaultHeader), SEEK_CUR) != EOK) {
		rc = ESIF_E_IO_ERROR;
		goto exit;
	}

	//
	// Write the key/value pairs to the memory stream for each data category
	// Fill in the data header for each category after the key/value pairs are written
	// Note: Only write persisted data
	//

	// Write All Persisted Rows from Sorted List to DataVault
	for (idx = 0; rc == ESIF_OK && idx < self->cache->size; idx++) {

		pairPtr = &self->cache->elements[idx];

		if (!(pairPtr->flags & ESIF_SERVICE_CONFIG_PERSIST)) {
			continue;
		}

		rc = DataVault_WriteKeyValuePair(self, pairPtr, memStreamPtr);
		if (rc != ESIF_OK) {
			goto exit;
		}
	}

	//
	// Now go back and complete the headers
	// Fill in and write the main header
	//

	if (IOStream_Open(memStreamPtr) != EOK) {
		rc = ESIF_E_IO_ERROR;
		goto exit;
	}

	DataVaultHeader header = { 0 };
	esif_ccb_memcpy(&header.signature, ESIFDV_SIGNATURE, sizeof(header.signature));
	header.headersize = sizeof(header);
	header.version = ESIFDV_VERSION(1, 0, ESIFDV_REVISION);
	header.flags = self->flags;

	if (IOStream_Write(memStreamPtr, &header, sizeof(header)) != sizeof(header)) {
		rc = ESIF_E_IO_ERROR;
		goto exit;
	}

	memStreamBuffer = IOStream_GetMemoryBuffer(memStreamPtr);
	memStreamBufSize = IOStream_GetSize(memStreamPtr);

	//
	// Now write the memory stream to the disk
	//
	if (rc == ESIF_OK && IOStream_OpenFile(diskStreamPtr, self->stream->file.name, "wb") != EOK) {
		rc = ESIF_E_IO_OPEN_FAILED;
		goto exit;
	}

	if (rc == ESIF_OK && (IOStream_Write(diskStreamPtr, memStreamBuffer, memStreamBufSize) != memStreamBufSize)) {
		rc = ESIF_E_IO_ERROR;
		goto exit;
	}
exit:
	IOStream_Destroy(diskStreamPtr);
	IOStream_Destroy(memStreamPtr);

	if (rc != ESIF_OK && cacheClonePtr != NULL) {
		DataCache_Destroy(self->cache);
		self->cache = cacheClonePtr;
	} else {
		DataCache_Destroy(cacheClonePtr);
	}

	return rc;
}
Beispiel #4
0
// Write DataVault to Disk
eEsifError DataVault_WriteVault (DataVaultPtr self)
{
	eEsifError rc = ESIF_E_NOT_FOUND;
	DataVaultHeader header;
	struct esif_ccb_file dv_file    = {0};
	struct esif_ccb_file dv_filebak = {0};
	IOStreamPtr vault    = 0;
	IOStreamPtr vaultBak = 0;
	u32 idx;

	if (FLAGS_TEST(self->flags, ESIF_SERVICE_CONFIG_STATIC | ESIF_SERVICE_CONFIG_READONLY)) {
		return ESIF_E_READONLY;
	}

	// TODO: Locking
	vault = IOStream_Create();
	if (!vault) {
		return ESIF_E_NO_MEMORY;
	}

	// If any rows contain NOCACHE PERSIST values, we need to make a copy the original DataVault while creating the new one
	// esif_ccb_sprintf(MAX_PATH, dv_file.filename, "%s%s", esif_build_path(dv_file.filename, MAX_PATH, NULL, self->name), ESIFDV_FILEEXT);
	esif_ccb_sprintf(MAX_PATH, dv_file.filename, "%s%s%s", ESIFDV_DIR, self->name, ESIFDV_FILEEXT);

	for (idx = 0; idx < self->cache->size; idx++)
		if (FLAGS_TESTALL(self->cache->elements[idx].flags, ESIF_SERVICE_CONFIG_NOCACHE | ESIF_SERVICE_CONFIG_PERSIST) &&
			self->cache->elements[idx].value.buf_len == 0) {
			struct stat filebak_stat = {0};
            esif_ccb_sprintf(MAX_PATH, dv_filebak.filename, "%s%s%s", ESIFDV_DIR, self->name, ESIFDV_BAKFILEEXT);

			// Delete BAK file if it exists
			if (esif_ccb_stat(dv_filebak.filename, &filebak_stat) == 0) {
				esif_ccb_unlink(dv_filebak.filename);
			}
			if (esif_ccb_rename(dv_file.filename, dv_filebak.filename) == 0) {
				if ((vaultBak = IOStream_Create()) == NULL) {
					rc = ESIF_E_NO_MEMORY;
				}
				if (!vaultBak || IOStream_OpenFile(vaultBak, dv_filebak.filename, "rb") != 0) {
					IOStream_Destroy(vault);
					IOStream_Destroy(vaultBak);
					return rc;
				}
			}
			break;
		}

	// Create DataVault, Overwrite if necessary
	IOStream_SetFile(vault, self->stream->file.name, "wb");
	if (IOStream_Open(vault) != 0) {
		if (vaultBak) {
			IOStream_Destroy(vaultBak);
			esif_ccb_unlink(dv_filebak.filename);
		}
		IOStream_Destroy(vault);
		return rc;
	}

	// Create File Header
	memset(&header, 0, sizeof(header));
	esif_ccb_memcpy(&header.signature, ESIFDV_SIGNATURE, sizeof(header.signature));
	header.headersize = sizeof(header);
	header.version    = ESIFDV_VERSION(ESIFDV_MAJOR_VERSION, ESIFDV_MINOR_VERSION, ESIFDV_REVISION);
	header.flags = 0;	// TODO: get from self->flags

	// Write File Header
	IOStream_Seek(vault, 0, SEEK_SET);
	IOStream_Write(vault, &header, sizeof(header));
	rc = ESIF_OK;

	// Write All Persisted Rows from Sorted List to DataVault
	for (idx = 0; idx < self->cache->size; idx++) {
		DataCacheEntryPtr keypair = &self->cache->elements[idx];
		if (keypair->flags & ESIF_SERVICE_CONFIG_PERSIST) {
			UInt8 *buffer     = 0;
			UInt32 buffer_len = 0;
			UInt32 byte = 0;

			IOStream_Write(vault, &keypair->flags, sizeof(keypair->flags));
			IOStream_Write(vault, &keypair->key.data_len, sizeof(keypair->key.data_len));
			IOStream_Write(vault, keypair->key.buf_ptr, keypair->key.data_len);

			IOStream_Write(vault, &keypair->value.type, sizeof(keypair->value.type));
			IOStream_Write(vault, &keypair->value.data_len, sizeof(keypair->value.data_len));

			// Read NOCACHE Entries from Backup file
			if (keypair->flags & ESIF_SERVICE_CONFIG_NOCACHE) {
				size_t offset = IOStream_GetOffset(vault);

				// Read Block from BAK file
				if (keypair->value.buf_len == 0) {
					size_t bakoffset = (size_t)keypair->value.buf_ptr;
					buffer     = (UInt8*)esif_ccb_malloc(keypair->value.data_len);
					buffer_len = keypair->value.data_len;
					if (!buffer) {
						rc = ESIF_E_NO_MEMORY;
						break;
					}
					if (IOStream_Seek(vaultBak, bakoffset, SEEK_SET) != 0 || IOStream_Read(vaultBak, buffer, buffer_len) != buffer_len) {
						esif_ccb_free(buffer);
						rc = ESIF_E_UNSPECIFIED;// TODO: ESIF_E_IOERROR;
						break;
					}
					keypair->value.buf_ptr = (void*)offset;
				}
				// Convert internal storage to NOCACHE
				else {
					buffer     = (UInt8*)keypair->value.buf_ptr;
					buffer_len = keypair->value.data_len;
					keypair->value.buf_ptr = (void*)offset;
					keypair->value.buf_len = 0;
				}
			}

			// Encrypt Data?
			if (keypair->flags & ESIF_SERVICE_CONFIG_ENCRYPT) {
				if (!buffer) {
					buffer     = (UInt8*)esif_ccb_malloc(keypair->value.data_len);
					buffer_len = keypair->value.data_len;
					if (!buffer) {
						rc = ESIF_E_NO_MEMORY;
						break;
					}
				}
				for (byte = 0; byte < keypair->value.data_len; byte++)
					buffer[byte] = ~((UInt8*)(keypair->value.buf_ptr))[byte];
			}

			if (buffer) {
				IOStream_Write(vault, buffer, buffer_len);
				esif_ccb_free(buffer);
			} else {
				IOStream_Write(vault, keypair->value.buf_ptr, keypair->value.data_len);
			}
		}
	}

	// Rollback on Error
	if (rc != ESIF_OK) {
		IOStream_Destroy(vaultBak);
		IOStream_Destroy(vault);
		esif_ccb_unlink(dv_file.filename);
		IGNORE_RESULT(esif_ccb_rename(dv_filebak.filename, dv_file.filename));
		return rc;
	}
	// Remove BAK file and Commit
	if (vaultBak) {
		IOStream_Close(vaultBak);
		esif_ccb_unlink(dv_filebak.filename);
		IOStream_Destroy(vaultBak);
	}
	IOStream_Close(vault);
	IOStream_Destroy(vault);
	return rc;
}