haiku.git

/*
 * Copyright 2016, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "CoreFile.h"

#include <errno.h>

#include <algorithm>

#include <OS.h>

#include <AutoDeleter.h>

#include "ElfSymbolLookup.h"
#include "Tracing.h"


static const size_t kMaxNotesSize = 10 * 1024 * 1024;


// pragma mark - CoreFileTeamInfo


CoreFileTeamInfo::CoreFileTeamInfo()
	:
	fId(-1),
	fUid(-1),
	fGid(-1),
	fArgs()
{
}


void
CoreFileTeamInfo::Init(int32 id, int32 uid, int32 gid, const BString& args)
{
	fId = id;
	fUid = uid;
	fGid = gid;
	fArgs = args;
}


// pragma mark - CoreFileAreaInfo


CoreFileAreaInfo::CoreFileAreaInfo(ElfSegment* segment, int32 id,
	uint64 baseAddress, uint64 size, uint64 ramSize, uint32 locking,
	uint32 protection, const BString& name)
	:
	fSegment(segment),
	fBaseAddress(baseAddress),
	fSize(size),
	fRamSize(ramSize),
	fLocking(locking),
	fProtection(protection),
	fId(-1)
{
}


// pragma mark - CoreFileImageInfo


CoreFileImageInfo::CoreFileImageInfo(int32 id, int32 type, uint64 initRoutine,
	uint64 termRoutine, uint64 textBase, uint64 textSize, int64 textDelta,
	uint64 dataBase, uint64 dataSize, int32 deviceId, int64 nodeId,
	uint64 symbolTable, uint64 symbolHash, uint64 stringTable,
	CoreFileAreaInfo* textArea, CoreFileAreaInfo* dataArea, const BString& name)
	:
	fId(id),
	fType(type),
	fInitRoutine(initRoutine),
	fTermRoutine(termRoutine),
	fTextBase(textBase),
	fTextSize(textSize),
	fTextDelta(textDelta),
	fDataBase(dataBase),
	fDataSize(dataSize),
	fDeviceId(deviceId),
	fNodeId(nodeId),
	fSymbolTable(symbolTable),
	fSymbolHash(symbolHash),
	fStringTable(stringTable),
	fTextArea(textArea),
	fDataArea(dataArea),
	fName(name),
	fSymbolsInfo(NULL)
{
}


CoreFileImageInfo::~CoreFileImageInfo()
{
	SetSymbolsInfo(NULL);
}


void
CoreFileImageInfo::SetSymbolsInfo(CoreFileSymbolsInfo* symbolsInfo)
{
	if (fSymbolsInfo != NULL)
		delete fSymbolsInfo;

	fSymbolsInfo = symbolsInfo;
}


// pragma mark - CoreFileSymbolsInfo

CoreFileSymbolsInfo::CoreFileSymbolsInfo()
	:
	fSymbolTable(NULL),
	fStringTable(NULL),
	fSymbolCount(0),
	fSymbolTableEntrySize(0),
	fStringTableSize(0)
{
}


CoreFileSymbolsInfo::~CoreFileSymbolsInfo()
{
	free(fSymbolTable);
	free(fStringTable);
}


bool
CoreFileSymbolsInfo::Init(const void* symbolTable, uint32 symbolCount,
	uint32 symbolTableEntrySize, const char* stringTable,
	uint32 stringTableSize)
{
	fSymbolTable = malloc(symbolCount * symbolTableEntrySize);
	fStringTable = (char*)malloc(stringTableSize);

	if (fSymbolTable == NULL || fStringTable == NULL)
		return false;

	memcpy(fSymbolTable, symbolTable, symbolCount * symbolTableEntrySize);
	memcpy(fStringTable, stringTable, stringTableSize);

	fSymbolCount = symbolCount;
	fSymbolTableEntrySize = symbolTableEntrySize;
	fStringTableSize = stringTableSize;

	return true;
}


// pragma mark - CoreFileThreadInfo


CoreFileThreadInfo::CoreFileThreadInfo(int32 id, int32 state, int32 priority,
	uint64 stackBase, uint64 stackEnd, const BString& name)
	:
	fId(id),
	fState(state),
	fPriority(priority),
	fStackBase(stackBase),
	fStackEnd(stackEnd),
	fName(name),
	fCpuState(NULL),
	fCpuStateSize(0)
{
}


CoreFileThreadInfo::~CoreFileThreadInfo()
{
	free(fCpuState);
}


bool
CoreFileThreadInfo::SetCpuState(const void* state, size_t size)
{
	free(fCpuState);
	fCpuState = NULL;
	fCpuStateSize = 0;

	if (state != NULL) {
		fCpuState = malloc(size);
		if (fCpuState == NULL)
			return false;
		memcpy(fCpuState, state, size);
		fCpuStateSize = size;
	}

	return true;
}


// pragma mark - CoreFile


CoreFile::CoreFile()
	:
	fElfFile(),
	fTeamInfo(),
	fAreaInfos(32),
	fImageInfos(32),
	fThreadInfos(32)
{
}


CoreFile::~CoreFile()
{
}


status_t
CoreFile::Init(const char* fileName)
{
	status_t error = fElfFile.Init(fileName);
	if (error != B_OK)
		return error;

	if (fElfFile.Is64Bit())
		return _Init<ElfClass64>();
	return _Init<ElfClass32>();
}


const CoreFileThreadInfo*
CoreFile::ThreadInfoForId(int32 id) const
{
	int32 count = fThreadInfos.CountItems();
	for (int32 i = 0; i < count; i++) {
		CoreFileThreadInfo* info = fThreadInfos.ItemAt(i);
		if (info->Id() == id)
			return info;
	}

	return NULL;
}


status_t
CoreFile::CreateSymbolLookup(const CoreFileImageInfo* imageInfo,
	ElfSymbolLookup*& _lookup)
{
	// get the needed data
	uint64 textDelta = imageInfo->TextDelta();
	uint64 symbolTable = imageInfo->SymbolTable();
	uint64 symbolHash = imageInfo->SymbolHash();
	uint64 stringTable = imageInfo->StringTable();
	CoreFileAreaInfo* textArea = imageInfo->TextArea();
	ElfSegment* textSegment = textArea != NULL ? textArea->Segment() : NULL;

	if (symbolTable == 0 || symbolHash == 0 || stringTable == 0
			|| textSegment == NULL) {
		return B_UNSUPPORTED;
	}

	// create a data source for the text segment
	ElfSymbolLookupSource* source = fElfFile.CreateSymbolLookupSource(
		textSegment->FileOffset(), textSegment->FileSize(),
		textSegment->LoadAddress());
	if (source == NULL)
		return B_NO_MEMORY;

	// get the symbol table entry size
	// TODO: This is not actually correct, since at least theoretically the
	// entry size may differ (cf. DT_SYMENT in the dynamic segment).
	size_t symbolTableEntrySize = fElfFile.Is64Bit()
		? sizeof(ElfClass64::Sym) : sizeof(ElfClass32::Sym);

	// create the symbol lookup
	return ElfSymbolLookup::Create(source, symbolTable, symbolHash, stringTable,
		ElfSymbolLookup::kGetSymbolCountFromHash, symbolTableEntrySize,
		textDelta, fElfFile.Is64Bit(), fElfFile.IsByteOrderSwapped(), true,
		_lookup);
}


template<typename ElfClass>
status_t
CoreFile::_Init()
{
	status_t error = _ReadNotes<ElfClass>();
	if (error != B_OK)
		return error;
printf("CoreFile::_Init(): got %" B_PRId32 " areas, %" B_PRId32 " images, %"
B_PRId32 " threads\n", CountAreaInfos(), CountImageInfos(), CountThreadInfos());
	// TODO: Verify that we actually read something!
	return B_OK;
}


template<typename ElfClass>
status_t
CoreFile::_ReadNotes()
{
	int32 count = fElfFile.CountSegments();
	for (int32 i = 0; i < count; i++) {
		ElfSegment* segment = fElfFile.SegmentAt(i);
		if (segment->Type() == PT_NOTE) {
			status_t error = _ReadNotes<ElfClass>(segment);
			if (error != B_OK)
				return error;
		}
	}

	return B_OK;
}


template<typename ElfClass>
status_t
CoreFile::_ReadNotes(ElfSegment* segment)
{
	// read the whole segment into memory
	if ((uint64)segment->FileSize() > kMaxNotesSize) {
		WARNING("Notes segment too large (%" B_PRIdOFF ")\n",
			segment->FileSize());
		return B_UNSUPPORTED;
	}

	size_t notesSize = (size_t)segment->FileSize();
	uint8* notes = (uint8*)malloc(notesSize);
	if (notes == NULL)
		return B_NO_MEMORY;
	MemoryDeleter notesDeleter(notes);

	ssize_t bytesRead = pread(fElfFile.FD(), notes, notesSize,
		(off_t)segment->FileOffset());
	if (bytesRead < 0) {
		WARNING("Failed to read notes segment: %s\n", strerror(errno));
		return errno;
	}
	if ((size_t)bytesRead != notesSize) {
		WARNING("Failed to read whole notes segment\n");
		return B_IO_ERROR;
	}

	// iterate through notes
	typedef typename ElfClass::Nhdr Nhdr;
	while (notesSize > 0) {
		if (notesSize < sizeof(Nhdr)) {
			WARNING("Remaining bytes in notes segment too short for header\n");
			return B_BAD_DATA;
		}

		const Nhdr* header = (const Nhdr*)notes;
		uint32 nameSize = Get(header->n_namesz);
		uint32 dataSize = Get(header->n_descsz);
		uint32 type = Get(header->n_type);

		notes += sizeof(Nhdr);
		notesSize -= sizeof(Nhdr);

		size_t alignedNameSize = (nameSize + 3) / 4 * 4;
		if (alignedNameSize > notesSize) {
			WARNING("Not enough bytes remaining in notes segment for note "
				"name (%zu / %zu)\n", notesSize, alignedNameSize);
			return B_BAD_DATA;
		}

		const char* name = (const char*)notes;
		size_t nameLen = strnlen(name, nameSize);
		if (nameLen == nameSize) {
			WARNING("Unterminated note name\n");
			return B_BAD_DATA;
		}

		notes += alignedNameSize;
		notesSize -= alignedNameSize;

		size_t alignedDataSize = (dataSize + 3) / 4 * 4;
		if (alignedDataSize > notesSize) {
			WARNING("Not enough bytes remaining in notes segment for note "
				"data\n");
			return B_BAD_DATA;
		}

		_ReadNote<ElfClass>(name, type, notes, dataSize);

		notes += alignedDataSize;
		notesSize -= alignedDataSize;
	}

	return B_OK;
}


template<typename ElfClass>
status_t
CoreFile::_ReadNote(const char* name, uint32 type, const void* data,
	uint32 dataSize)
{
	if (strcmp(name, ELF_NOTE_CORE) == 0) {
		switch (type) {
			case NT_FILE:
				// not needed
				return B_OK;
		}
	} else if (strcmp(name, ELF_NOTE_HAIKU) == 0) {
		switch (type) {
			case NT_TEAM:
				return _ReadTeamNote<ElfClass>(data, dataSize);
			case NT_AREAS:
				return _ReadAreasNote<ElfClass>(data, dataSize);
			case NT_IMAGES:
				return _ReadImagesNote<ElfClass>(data, dataSize);
			case NT_SYMBOLS:
				return _ReadSymbolsNote<ElfClass>(data, dataSize);
			case NT_THREADS:
				return _ReadThreadsNote<ElfClass>(data, dataSize);
			break;
		}
	}

	WARNING("Unsupported note type %s/%#" B_PRIx32 "\n", name, type);
	return B_OK;
}


template<typename ElfClass>
status_t
CoreFile::_ReadTeamNote(const void* data, uint32 dataSize)
{
	typedef typename ElfClass::NoteTeam NoteTeam;

	if (dataSize < sizeof(uint32)) {
		WARNING("Team note too short\n");
		return B_BAD_DATA;
	}
	uint32 entrySize = Get(*(const uint32*)data);
	data = (const uint32*)data + 1;
	dataSize -= sizeof(uint32);

	if (entrySize == 0 || dataSize == 0 || dataSize - 1 < entrySize) {
		WARNING("Team note: too short or invalid entry size (%" B_PRIu32 ")\n",
			entrySize);
		return B_BAD_DATA;
	}

	NoteTeam note = {};
	_ReadEntry(data, dataSize, note, entrySize);

	// check, if args are null-terminated
	const char* args = (const char*)data;
	size_t argsSize = dataSize;
	if (args[argsSize - 1] != '\0') {
		WARNING("Team note args not terminated\n");
		return B_BAD_DATA;
	}

	int32 id = Get(note.nt_id);
	int32 uid = Get(note.nt_uid);
	int32 gid = Get(note.nt_gid);

	BString copiedArgs(args);
	if (args[0] != '\0' && copiedArgs.Length() == 0)
		return B_NO_MEMORY;

	fTeamInfo.Init(id, uid, gid, copiedArgs);
	return B_OK;
}


template<typename ElfClass>
status_t
CoreFile::_ReadAreasNote(const void* data, uint32 dataSize)
{
	if (dataSize < 2 * sizeof(uint32)) {
		WARNING("Areas note too short\n");
		return B_BAD_DATA;
	}
	uint32 areaCount = _ReadValue<uint32>(data, dataSize);
	uint32 entrySize = _ReadValue<uint32>(data, dataSize);

	typedef typename ElfClass::NoteAreaEntry Entry;

	if (areaCount == 0)
		return B_OK;

	// check entry size and area count
	if (entrySize == 0 || dataSize == 0 || areaCount > dataSize
			|| dataSize - 1 < entrySize || areaCount * entrySize >= dataSize) {
		WARNING("Areas note: too short or invalid entry size (%" B_PRIu32 ")\n",
			entrySize);
		return B_BAD_DATA;
	}

	// check, if strings are null-terminated
	const char* strings = (const char*)data + areaCount * entrySize;
	size_t stringsSize = dataSize - areaCount * entrySize;
	if (stringsSize == 0 || strings[stringsSize - 1] != '\0') {
		WARNING("Areas note strings not terminated\n");
		return B_BAD_DATA;
	}

	for (uint64 i = 0; i < areaCount; i++) {
		// get entry values
		Entry entry = {};
		_ReadEntry(data, dataSize, entry, entrySize);

		int32 id = Get(entry.na_id);
		uint64 baseAddress = Get(entry.na_base);
		uint64 size = Get(entry.na_size);
		uint64 ramSize = Get(entry.na_ram_size);
		uint32 lock = Get(entry.na_lock);
		uint32 protection = Get(entry.na_protection);

		// get name
		if (stringsSize == 0) {
			WARNING("Area %" B_PRIu64 " (ID %#" B_PRIx32 " @ %#" B_PRIx64
				") has no name\n", i, id, baseAddress);
			continue;
		}
		const char* name = strings;
		size_t nameSize = strlen(name) + 1;
		strings += nameSize;
		stringsSize -= nameSize;

		BString copiedName(name);
		if (name[0] != '\0' && copiedName.Length() == 0)
			return B_NO_MEMORY;

		// create and add area
		ElfSegment* segment = _FindAreaSegment(baseAddress);
		if (segment == NULL) {
			WARNING("No matching segment found for area %" B_PRIu64 " (ID %#"
				B_PRIx32 " @ %#" B_PRIx64 ", name: '%s')", i, id, baseAddress,
				name);
			continue;
		}

		CoreFileAreaInfo* area = new(std::nothrow) CoreFileAreaInfo(segment, id,
			baseAddress, size, ramSize, lock, protection, copiedName);
		if (area == NULL || !fAreaInfos.AddItem(area)) {
			delete area;
			return B_NO_MEMORY;
		}
	}

	return B_OK;
}


template<typename ElfClass>
status_t
CoreFile::_ReadImagesNote(const void* data, uint32 dataSize)
{
	if (dataSize < 2 * sizeof(uint32)) {
		WARNING("Images note too short\n");
		return B_BAD_DATA;
	}
	uint32 imageCount = _ReadValue<uint32>(data, dataSize);
	uint32 entrySize = _ReadValue<uint32>(data, dataSize);

	typedef typename ElfClass::NoteImageEntry Entry;

	if (imageCount == 0)
		return B_OK;

	// check entry size and image count
	if (entrySize == 0 || dataSize == 0 || imageCount > dataSize
			|| dataSize - 1 < entrySize || imageCount * entrySize >= dataSize) {
		WARNING("Images note: too short or invalid entry size (%" B_PRIu32
			")\n", entrySize);
		return B_BAD_DATA;
	}

	// check, if strings are null-terminated
	const char* strings = (const char*)data + imageCount * entrySize;
	size_t stringsSize = dataSize - imageCount * entrySize;
	if (stringsSize == 0 || strings[stringsSize - 1] != '\0') {
		WARNING("Images note strings not terminated\n");
		return B_BAD_DATA;
	}

	for (uint64 i = 0; i < imageCount; i++) {
		// get entry values
		Entry entry = {};
		_ReadEntry(data, dataSize, entry, entrySize);

		int32 id = Get(entry.ni_id);
		int32 type = Get(entry.ni_type);
		uint64 initRoutine = Get(entry.ni_init_routine);
		uint64 termRoutine = Get(entry.ni_term_routine);
		uint64 textBase = Get(entry.ni_text_base);
		uint64 textSize = Get(entry.ni_text_size);
		int64 textDelta = Get(entry.ni_text_delta);
		uint64 dataBase = Get(entry.ni_data_base);
		uint64 dataSize = Get(entry.ni_data_size);
		int32 deviceId = Get(entry.ni_device);
		int64 nodeId = Get(entry.ni_node);
		uint64 symbolTable = Get(entry.ni_symbol_table);
		uint64 symbolHash = Get(entry.ni_symbol_hash);
		uint64 stringTable = Get(entry.ni_string_table);

		// get name
		if (stringsSize == 0) {
			WARNING("Image %" B_PRIu64 " (ID %#" B_PRIx32 ") has no name\n",
				i, id);
			continue;
		}
		const char* name = strings;
		size_t nameSize = strlen(name) + 1;
		strings += nameSize;
		stringsSize -= nameSize;

		BString copiedName(name);
		if (name[0] != '\0' && copiedName.Length() == 0)
			return B_NO_MEMORY;

		// create and add image
		CoreFileAreaInfo* textArea = _FindArea(textBase);
		CoreFileAreaInfo* dataArea = _FindArea(dataBase);
		CoreFileImageInfo* image = new(std::nothrow) CoreFileImageInfo(id, type,
			initRoutine, termRoutine, textBase, textSize, textDelta, dataBase,
			dataSize, deviceId, nodeId, symbolTable, symbolHash, stringTable,
			textArea, dataArea, copiedName);
		if (image == NULL || !fImageInfos.AddItem(image)) {
			delete image;
			return B_NO_MEMORY;
		}
	}

	return B_OK;
}


template<typename ElfClass>
status_t
CoreFile::_ReadSymbolsNote(const void* data, uint32 dataSize)
{
	if (dataSize < 3 * sizeof(uint32)) {
		WARNING("Symbols note too short\n");
		return B_BAD_DATA;
	}
	int32 imageId = _ReadValue<int32>(data, dataSize);
	uint32 symbolCount = _ReadValue<uint32>(data, dataSize);
	uint32 entrySize = _ReadValue<uint32>(data, dataSize);

	typedef typename ElfClass::Sym Sym;

	if (symbolCount == 0)
		return B_OK;

	// get the corresponding image
	CoreFileImageInfo* imageInfo = _ImageInfoForId(imageId);
	if (imageInfo == NULL) {
		WARNING("Symbols note: image (ID %" B_PRId32 ") not found\n",
			entrySize);
		return B_BAD_DATA;
	}

	// check entry size and symbol count
	if (entrySize < sizeof(Sym) || symbolCount > dataSize
			|| dataSize - 1 < entrySize
			|| symbolCount * entrySize >= dataSize - 1) {
		WARNING("Symbols note: too short or invalid entry size (%" B_PRIu32
			")\n", entrySize);
		return B_BAD_DATA;
	}

	uint32 symbolTableSize = symbolCount * entrySize;
	uint32 stringTableSize = dataSize - symbolTableSize;

	// check, if the string table is null-terminated
	const char* stringTable = (const char*)data + symbolTableSize;
	if (stringTableSize == 0 || stringTable[stringTableSize - 1] != '\0') {
		WARNING("Symbols note string table not terminated\n");
		return B_BAD_DATA;
	}

	CoreFileSymbolsInfo* symbolsInfo = new(std::nothrow) CoreFileSymbolsInfo;
	if (symbolsInfo == NULL
			|| !symbolsInfo->Init(data, symbolCount, entrySize, stringTable,
					stringTableSize)) {
		delete symbolsInfo;
		return B_NO_MEMORY;
	}

	imageInfo->SetSymbolsInfo(symbolsInfo);

	return B_OK;
}


template<typename ElfClass>
status_t
CoreFile::_ReadThreadsNote(const void* data, uint32 dataSize)
{
	if (dataSize < 3 * sizeof(uint32)) {
		WARNING("Threads note too short\n");
		return B_BAD_DATA;
	}
	uint32 threadCount = _ReadValue<uint32>(data, dataSize);
	uint32 entrySize = _ReadValue<uint32>(data, dataSize);
	uint32 cpuStateSize = _ReadValue<uint32>(data, dataSize);

	if (cpuStateSize > 1024 * 1024) {
		WARNING("Threads note: unreasonable CPU state size: %" B_PRIu32 "\n",
			cpuStateSize);
		return B_BAD_DATA;
	}

	typedef typename ElfClass::NoteThreadEntry Entry;

	if (threadCount == 0)
		return B_OK;

	size_t totalEntrySize = entrySize + cpuStateSize;

	// check entry size and thread count
	if (entrySize == 0 || dataSize == 0 || threadCount > dataSize
			|| entrySize > dataSize || cpuStateSize > dataSize
			|| dataSize - 1 < totalEntrySize
			|| threadCount * totalEntrySize >= dataSize) {
		WARNING("Threads note: too short or invalid entry size (%" B_PRIu32
			")\n", entrySize);
		return B_BAD_DATA;
	}

	// check, if strings are null-terminated
	const char* strings = (const char*)data + threadCount * totalEntrySize;
	size_t stringsSize = dataSize - threadCount * totalEntrySize;
	if (stringsSize == 0 || strings[stringsSize - 1] != '\0') {
		WARNING("Threads note strings not terminated\n");
		return B_BAD_DATA;
	}

	for (uint64 i = 0; i < threadCount; i++) {
		// get entry values
		Entry entry = {};
		_ReadEntry(data, dataSize, entry, entrySize);

		int32 id = Get(entry.nth_id);
		int32 state = Get(entry.nth_state);
		int32 priority = Get(entry.nth_priority);
		uint64 stackBase = Get(entry.nth_stack_base);
		uint64 stackEnd = Get(entry.nth_stack_end);

		// get name
		if (stringsSize == 0) {
			WARNING("Thread %" B_PRIu64 " (ID %#" B_PRIx32 ") has no name\n",
				i, id);
			continue;
		}
		const char* name = strings;
		size_t nameSize = strlen(name) + 1;
		strings += nameSize;
		stringsSize -= nameSize;

		BString copiedName(name);
		if (name[0] != '\0' && copiedName.Length() == 0)
			return B_NO_MEMORY;

		// create and add thread
		CoreFileThreadInfo* thread = new(std::nothrow) CoreFileThreadInfo(id,
			state, priority, stackBase, stackEnd, copiedName);
		if (thread == NULL || !fThreadInfos.AddItem(thread)) {
			delete thread;
			return B_NO_MEMORY;
		}

		// get CPU state
		if (!thread->SetCpuState(data, cpuStateSize))
			return B_NO_MEMORY;
		_Advance(data, dataSize, cpuStateSize);
	}

	return B_OK;
}


CoreFileAreaInfo*
CoreFile::_FindArea(uint64 address) const
{
	int32 count = fAreaInfos.CountItems();
	for (int32 i = 0; i < count; i++) {
		CoreFileAreaInfo* area = fAreaInfos.ItemAt(i);
		if (address >= area->BaseAddress()
				&& address < area->EndAddress()) {
			return area;
		}
	}

	return NULL;
}


ElfSegment*
CoreFile::_FindAreaSegment(uint64 address) const
{
	int32 count = fElfFile.CountSegments();
	for (int32 i = 0; i < count; i++) {
		ElfSegment* segment = fElfFile.SegmentAt(i);
		if (segment->Type() == PT_LOAD && segment->LoadAddress() == address)
			return segment;
	}

	return NULL;
}


CoreFileImageInfo*
CoreFile::_ImageInfoForId(int32 id) const
{
	int32 count = fImageInfos.CountItems();
	for (int32 i = 0; i < count; i++) {
		CoreFileImageInfo* info = fImageInfos.ItemAt(i);
		if (info->Id() == id)
			return info;
	}

	return NULL;
}


template<typename Type>
Type
CoreFile::_ReadValue(const void*& data, uint32& dataSize)
{
	Type value = Get(*(const Type*)data);
	_Advance(data, dataSize, sizeof(Type));
	return value;
}


template<typename Entry>
void
CoreFile::_ReadEntry(const void*& data, uint32& dataSize, Entry& entry,
	size_t entrySize)
{
	memcpy(&entry, data, std::min(sizeof(entry), entrySize));
	_Advance(data, dataSize, entrySize);
}


void
CoreFile::_Advance(const void*& data, uint32& dataSize, size_t by)
{
	data = (const uint8*)data + by;
	dataSize -= by;
}