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


/*!
	\file ResourceFile.cpp
	ResourceFile implementation.
*/


#include <ResourceFile.h>

#include <algorithm>
#include <new>
#include <stdio.h>

#include <AutoDeleter.h>
#include <BufferIO.h>
#include <Elf.h>
#include <Exception.h>
#include <Pef.h>
#include <ResourceItem.h>
#include <ResourcesContainer.h>
#include <ResourcesDefs.h>
//#include <Warnings.h>


namespace BPrivate {
namespace Storage {


// ELF defs
static const uint32	kMaxELFHeaderSize
	= std::max(sizeof(Elf32_Ehdr), sizeof(Elf64_Ehdr)) + 32;
static const char	kELFFileMagic[4]			= { 0x7f, 'E', 'L', 'F' };

// sanity bounds
static const uint32	kMaxResourceCount			= 10000;
static const uint32	kELFMaxResourceAlignment	= 1024 * 1024 * 10;	// 10 MB


// recognized file types (indices into kFileTypeNames)
enum {
	FILE_TYPE_UNKNOWN		= 0,
	FILE_TYPE_X86_RESOURCE	= 1,
	FILE_TYPE_PPC_RESOURCE	= 2,
	FILE_TYPE_ELF			= 3,
	FILE_TYPE_PEF			= 4,
	FILE_TYPE_EMPTY			= 5,
};


const char* kFileTypeNames[] = {
	"unknown",
	"x86 resource file",
	"PPC resource file",
	"ELF object file",
	"PEF object file",
	"empty file",
};


// debugging
//#define DBG(x) x
#define DBG(x)
#define OUT	printf

#define B_VERSION_INFO_TYPE 'APPV'

static const uint32 kVersionInfoIntCount = 5;

// #pragma mark - helper functions/classes


static void
read_exactly(BPositionIO& file, off_t position, void* buffer, size_t size,
	const char* errorMessage = NULL)
{
	ssize_t read = file.ReadAt(position, buffer, size);
	if (read < 0)
		throw Exception(read, errorMessage);
	else if ((size_t)read != size) {
		if (errorMessage) {
			throw Exception("%s Read too few bytes (%ld/%lu).", errorMessage,
							read, size);
		} else
			throw Exception("Read too few bytes (%ld/%lu).", read, size);
	}
}


static void
write_exactly(BPositionIO& file, off_t position, const void* buffer,
	size_t size, const char* errorMessage = NULL)
{
	ssize_t written = file.WriteAt(position, buffer, size);
	if (written < 0)
		throw Exception(written, errorMessage);
	else if ((size_t)written != size) {
		if (errorMessage) {
			throw Exception("%s Wrote too few bytes (%ld/%lu).", errorMessage,
							written, size);
		} else
			throw Exception("Wrote too few bytes (%ld/%lu).", written, size);
	}
}


template<typename TV, typename TA>
static inline TV
align_value(const TV& value, const TA& alignment)
{
	return ((value + alignment - 1) / alignment) * alignment;
}


static uint32
calculate_checksum(const void* data, uint32 size)
{
	uint32 checkSum = 0;
	const uint8* csData = (const uint8*)data;
	const uint8* dataEnd = csData + size;
	const uint8* current = csData;
	for (; current < dataEnd; current += 4) {
		uint32 word = 0;
		int32 bytes = std::min((int32)4, (int32)(dataEnd - current));
		for (int32 i = 0; i < bytes; i++)
			word = (word << 8) + current[i];
		checkSum += word;
	}
	return checkSum;
}


static inline const void*
skip_bytes(const void* buffer, int32 offset)
{
	return (const char*)buffer + offset;
}


static inline void*
skip_bytes(void* buffer, int32 offset)
{
	return (char*)buffer + offset;
}


static void
fill_pattern(uint32 byteOffset, void* _buffer, uint32 count)
{
	uint32* buffer = (uint32*)_buffer;
	for (uint32 i = 0; i < count; i++)
		buffer[i] = kUnusedResourceDataPattern[(byteOffset / 4 + i) % 3];
}


static void
fill_pattern(const void* dataBegin, void* buffer, uint32 count)
{
	fill_pattern((char*)buffer - (const char*)dataBegin, buffer, count);
}


static void
fill_pattern(const void* dataBegin, void* buffer, const void* bufferEnd)
{
	fill_pattern(dataBegin, buffer,
				 ((const char*)bufferEnd - (char*)buffer) / 4);
}


static bool
check_pattern(uint32 byteOffset, void* _buffer, uint32 count,
	bool hostEndianess)
{
	bool result = true;
	uint32* buffer = (uint32*)_buffer;
	for (uint32 i = 0; result && i < count; i++) {
		uint32 value = buffer[i];
		if (!hostEndianess)
			value = B_SWAP_INT32(value);
		result
			= (value == kUnusedResourceDataPattern[(byteOffset / 4 + i) % 3]);
	}
	return result;
}


// #pragma mark -


struct MemArea {
	MemArea(const void* data, uint32 size) : data(data), size(size) {}

	inline bool check(const void* _current, uint32 skip = 0) const
	{
		const char* start = (const char*)data;
		const char* current = (const char*)_current;
		return (start <= current && start + size >= current + skip);
	}

	const void*	data;
	uint32		size;
};


struct resource_parse_info {
	off_t				file_size;
	int32				resource_count;
	ResourcesContainer*	container;
	char*				info_table;
	uint32				info_table_offset;
	uint32				info_table_size;
};


// #pragma mark -


ResourceFile::ResourceFile()
	:
	fFile(),
	fFileType(FILE_TYPE_UNKNOWN),
	fHostEndianess(true),
	fEmptyResources(true)
{
}


ResourceFile::~ResourceFile()
{
	Unset();
}


status_t
ResourceFile::SetTo(BFile* file, bool clobber)
{
	status_t error = (file ? B_OK : B_BAD_VALUE);
	Unset();
	if (error == B_OK) {
		try {
			_InitFile(*file, clobber);
		} catch (Exception& exception) {
			Unset();
			if (exception.Error() != B_OK)
				error = exception.Error();
			else
				error = B_ERROR;
		}
	}
	return error;
}


void
ResourceFile::Unset()
{
	fFile.Unset();
	fFileType = FILE_TYPE_UNKNOWN;
	fHostEndianess = true;
	fEmptyResources = true;
}


status_t
ResourceFile::InitCheck() const
{
	return fFile.InitCheck();
}


status_t
ResourceFile::InitContainer(ResourcesContainer& container)
{
	container.MakeEmpty();
	status_t error = InitCheck();
	if (error == B_OK && !fEmptyResources) {
		resource_parse_info parseInfo;
		parseInfo.file_size = 0;
		parseInfo.resource_count = 0;
		parseInfo.container = &container;
		parseInfo.info_table = NULL;
		parseInfo.info_table_offset = 0;
		parseInfo.info_table_size = 0;
		try {
			// get the file size
			error = fFile.GetSize(&parseInfo.file_size);
			if (error != B_OK)
				throw Exception(error, "Failed to get the file size.");
			_ReadHeader(parseInfo);
			_ReadIndex(parseInfo);
			_ReadInfoTable(parseInfo);
			container.SetModified(false);
		} catch (Exception& exception) {
			if (exception.Error() != B_OK)
				error = exception.Error();
			else
				error = B_ERROR;
		}
		delete[] parseInfo.info_table;
	}
	return error;
}


status_t
ResourceFile::ReadResource(ResourceItem& resource, bool force)
{
	status_t error = InitCheck();
	size_t size = resource.DataSize();
	if (error == B_OK && (force || !resource.IsLoaded())) {
		void* data = NULL;
		error = resource.SetSize(size);

		if (error == B_OK) {
			data = resource.Data();
			ssize_t bytesRead = fFile.ReadAt(resource.Offset(), data, size);
			if (bytesRead < 0)
				error = bytesRead;
			else if ((size_t)bytesRead != size)
				error = B_IO_ERROR;
		}
		if (error == B_OK) {
			// convert the data, if necessary
			if (!fHostEndianess) {
				if (resource.Type() == B_VERSION_INFO_TYPE) {
					// Version info contains integers that need to be swapped
					swap_data(B_UINT32_TYPE, data,
						kVersionInfoIntCount * sizeof(uint32),
						B_SWAP_ALWAYS);
				} else
					swap_data(resource.Type(), data, size, B_SWAP_ALWAYS);
			}
			resource.SetLoaded(true);
			resource.SetModified(false);
		}
	}
	return error;
}


status_t
ResourceFile::ReadResources(ResourcesContainer& container, bool force)
{
	status_t error = InitCheck();
	int32 count = container.CountResources();
	for (int32 i = 0; error == B_OK && i < count; i++) {
		if (ResourceItem* resource = container.ResourceAt(i))
			error = ReadResource(*resource, force);
		else
			error = B_ERROR;
	}
	return error;
}


status_t
ResourceFile::WriteResources(ResourcesContainer& container)
{
	status_t error = InitCheck();
	if (error == B_OK && !fFile.File()->IsWritable())
		error = B_NOT_ALLOWED;
	if (error == B_OK && fFileType == FILE_TYPE_EMPTY)
		error = _MakeEmptyResourceFile();
	if (error == B_OK)
		error = _WriteResources(container);
	if (error == B_OK)
		fEmptyResources = false;
	return error;
}


void
ResourceFile::_InitFile(BFile& file, bool clobber)
{
	status_t error = B_OK;
	fFile.Unset();
	// get the file size first
	off_t fileSize = 0;
	error = file.GetSize(&fileSize);
	if (error != B_OK)
		throw Exception(error, "Failed to get the file size.");
	// read the first four bytes, and check, if they identify a resource file
	char magic[4];
	if (fileSize >= 4)
		read_exactly(file, 0, magic, 4, "Failed to read magic number.");
	else if (fileSize > 0 && !clobber)
		throw Exception(B_IO_ERROR, "File is not a resource file.");
	if (fileSize == 0) {
		// empty file
		fHostEndianess = true;
		fFileType = FILE_TYPE_EMPTY;
		fFile.SetTo(&file, 0);
		fEmptyResources = true;
	} else if (!memcmp(magic, kX86ResourceFileMagic, 4)) {
		// x86 resource file
		fHostEndianess = B_HOST_IS_LENDIAN;
		fFileType = FILE_TYPE_X86_RESOURCE;
		fFile.SetTo(&file, kX86ResourcesOffset);
		fEmptyResources = false;
	} else if (!memcmp(magic, kPEFFileMagic1, 4)) {
		PEFContainerHeader pefHeader;
		read_exactly(file, 0, &pefHeader, kPEFContainerHeaderSize,
			"Failed to read PEF container header.");
		if (!memcmp(pefHeader.tag2, kPPCResourceFileMagic, 4)) {
			// PPC resource file
			fHostEndianess = B_HOST_IS_BENDIAN;
			fFileType = FILE_TYPE_PPC_RESOURCE;
			fFile.SetTo(&file, kPPCResourcesOffset);
			fEmptyResources = false;
		} else if (!memcmp(pefHeader.tag2, kPEFFileMagic2, 4)) {
			// PEF file
			fFileType = FILE_TYPE_PEF;
			_InitPEFFile(file, pefHeader);
		} else
			throw Exception(B_IO_ERROR, "File is not a resource file.");
	} else if (!memcmp(magic, kELFFileMagic, 4)) {
		// ELF file
		fFileType = FILE_TYPE_ELF;
		_InitELFFile(file);
	} else if (!memcmp(magic, kX86ResourceFileMagic, 2)) {
		// x86 resource file with screwed magic?
//		Warnings::AddCurrentWarning("File magic is 0x%08lx. Should be 0x%08lx "
//									"for x86 resource file. Try anyway.",
//									ntohl(*(uint32*)magic),
//									ntohl(*(uint32*)kX86ResourceFileMagic));
		fHostEndianess = B_HOST_IS_LENDIAN;
		fFileType = FILE_TYPE_X86_RESOURCE;
		fFile.SetTo(&file, kX86ResourcesOffset);
		fEmptyResources = true;
	} else {
		if (clobber) {
			// make it an x86 resource file
			fHostEndianess = true;
			fFileType = FILE_TYPE_EMPTY;
			fFile.SetTo(&file, 0);
		} else
			throw Exception(B_IO_ERROR, "File is not a resource file.");
	}
	error = fFile.InitCheck();
	if (error != B_OK)
		throw Exception(error, "Failed to initialize resource file.");
	// clobber, if desired
	if (clobber) {
		// just write an empty resources container
		ResourcesContainer container;
		WriteResources(container);
	}
}


void
ResourceFile::_InitELFFile(BFile& file)
{
	status_t error = B_OK;

	// get the file size
	off_t fileSize = 0;
	error = file.GetSize(&fileSize);
	if (error != B_OK)
		throw Exception(error, "Failed to get the file size.");

	// read the ELF headers e_ident field
	unsigned char identification[EI_NIDENT];
	read_exactly(file, 0, identification, EI_NIDENT,
		"Failed to read ELF identification.");

	// check version
	if (identification[EI_VERSION] != EV_CURRENT)
		throw Exception(B_UNSUPPORTED, "Unsupported ELF version.");

	// check data encoding (endianess)
	switch (identification[EI_DATA]) {
		case ELFDATA2LSB:
			fHostEndianess = B_HOST_IS_LENDIAN;
			break;
		case ELFDATA2MSB:
			fHostEndianess = B_HOST_IS_BENDIAN;
			break;
		default:
		case ELFDATANONE:
			throw Exception(B_UNSUPPORTED, "Unsupported ELF data encoding.");
	}

	// check class (32/64 bit) and call the respective method handling it
	switch (identification[EI_CLASS]) {
		case ELFCLASS32:
			_InitELFXFile<Elf32_Ehdr, Elf32_Phdr, Elf32_Shdr>(file, fileSize);
			break;
		case ELFCLASS64:
			_InitELFXFile<Elf64_Ehdr, Elf64_Phdr, Elf64_Shdr>(file, fileSize);
			break;
		default:
			throw Exception(B_UNSUPPORTED, "Unsupported ELF class.");
	}
}


template<typename ElfHeader, typename ElfProgramHeader,
	typename ElfSectionHeader>
void
ResourceFile::_InitELFXFile(BFile& file, uint64 fileSize)
{
	// read ELF header
	ElfHeader fileHeader;
	read_exactly(file, 0, &fileHeader, sizeof(ElfHeader),
		"Failed to read ELF header.");

	// get the header values
	uint32 headerSize				= _GetInt(fileHeader.e_ehsize);
	uint64 programHeaderTableOffset	= _GetInt(fileHeader.e_phoff);
	uint32 programHeaderSize		= _GetInt(fileHeader.e_phentsize);
	uint32 programHeaderCount		= _GetInt(fileHeader.e_phnum);
	uint64 sectionHeaderTableOffset	= _GetInt(fileHeader.e_shoff);
	uint32 sectionHeaderSize		= _GetInt(fileHeader.e_shentsize);
	uint32 sectionHeaderCount		= _GetInt(fileHeader.e_shnum);
	bool hasProgramHeaderTable = (programHeaderTableOffset != 0);
	bool hasSectionHeaderTable = (sectionHeaderTableOffset != 0);

	// check the sanity of the header values
	// ELF header size
	if (headerSize < sizeof(ElfHeader) || headerSize > kMaxELFHeaderSize) {
		throw Exception(B_IO_ERROR,
			"Invalid ELF header: invalid ELF header size: %" B_PRIu32 ".",
			headerSize);
	}
	uint64 resourceOffset = headerSize;
	uint64 resourceAlignment = 0;

	// program header table offset and entry count/size
	uint64 programHeaderTableSize = 0;
	if (hasProgramHeaderTable) {
		if (programHeaderTableOffset < headerSize
			|| programHeaderTableOffset > fileSize) {
			throw Exception(B_IO_ERROR, "Invalid ELF header: invalid program "
				"header table offset: %lu.", programHeaderTableOffset);
		}
		programHeaderTableSize = (uint64)programHeaderSize * programHeaderCount;
		if (programHeaderSize < sizeof(ElfProgramHeader)
			|| programHeaderTableOffset + programHeaderTableSize > fileSize) {
			throw Exception(B_IO_ERROR, "Invalid ELF header: program header "
				"table exceeds file: %lu.",
				programHeaderTableOffset + programHeaderTableSize);
		}
		resourceOffset = std::max(resourceOffset,
			programHeaderTableOffset + programHeaderTableSize);

		// load the program headers into memory
		uint8* programHeaders = (uint8*)malloc(
			programHeaderCount * programHeaderSize);
		if (programHeaders == NULL)
			throw Exception(B_NO_MEMORY);
		MemoryDeleter programHeadersDeleter(programHeaders);

		read_exactly(file, programHeaderTableOffset, programHeaders,
			programHeaderCount * programHeaderSize,
			"Failed to read ELF program headers.");

		// iterate through the program headers
		for (uint32 i = 0; i < programHeaderCount; i++) {
			ElfProgramHeader& programHeader
				= *(ElfProgramHeader*)(programHeaders + i * programHeaderSize);

			// get the header values
			uint32 type			= _GetInt(programHeader.p_type);
			uint64 offset		= _GetInt(programHeader.p_offset);
			uint64 size			= _GetInt(programHeader.p_filesz);
			uint64 alignment	= _GetInt(programHeader.p_align);

			// check the values
			// PT_NULL marks the header unused,
			if (type != PT_NULL) {
				if (/*offset < headerSize ||*/ offset > fileSize) {
					throw Exception(B_IO_ERROR, "Invalid ELF program header: "
						"invalid program offset: %lu.", offset);
				}
				uint64 segmentEnd = offset + size;
				if (segmentEnd > fileSize) {
					throw Exception(B_IO_ERROR, "Invalid ELF section header: "
						"segment exceeds file: %lu.", segmentEnd);
				}
				resourceOffset = std::max(resourceOffset, segmentEnd);
				resourceAlignment = std::max(resourceAlignment, alignment);
			}
		}
	}

	// section header table offset and entry count/size
	uint64 sectionHeaderTableSize = 0;
	if (hasSectionHeaderTable) {
		if (sectionHeaderTableOffset < headerSize
			|| sectionHeaderTableOffset > fileSize) {
			throw Exception(B_IO_ERROR, "Invalid ELF header: invalid section "
				"header table offset: %lu.", sectionHeaderTableOffset);
		}
		sectionHeaderTableSize = (uint64)sectionHeaderSize * sectionHeaderCount;
		if (sectionHeaderSize < sizeof(ElfSectionHeader)
			|| sectionHeaderTableOffset + sectionHeaderTableSize > fileSize) {
			throw Exception(B_IO_ERROR, "Invalid ELF header: section header "
				"table exceeds file: %lu.",
				sectionHeaderTableOffset + sectionHeaderTableSize);
		}
		resourceOffset = std::max(resourceOffset,
			sectionHeaderTableOffset + sectionHeaderTableSize);

		// load the section headers into memory
		uint8* sectionHeaders = (uint8*)malloc(
			sectionHeaderCount * sectionHeaderSize);
		if (sectionHeaders == NULL)
			throw Exception(B_NO_MEMORY);
		MemoryDeleter sectionHeadersDeleter(sectionHeaders);

		read_exactly(file, sectionHeaderTableOffset, sectionHeaders,
			sectionHeaderCount * sectionHeaderSize,
			"Failed to read ELF section headers.");

		// iterate through the section headers
		for (uint32 i = 0; i < sectionHeaderCount; i++) {
			ElfSectionHeader& sectionHeader
				= *(ElfSectionHeader*)(sectionHeaders + i * sectionHeaderSize);

			// get the header values
			uint32 type		= _GetInt(sectionHeader.sh_type);
			uint64 offset	= _GetInt(sectionHeader.sh_offset);
			uint64 size		= _GetInt(sectionHeader.sh_size);

			// check the values
			// SHT_NULL marks the header unused,
			// SHT_NOBITS sections take no space in the file
			if (type != SHT_NULL && type != SHT_NOBITS) {
				if (offset < headerSize || offset > fileSize) {
					throw Exception(B_IO_ERROR, "Invalid ELF section header: "
						"invalid section offset: %lu.", offset);
				}
				uint64 sectionEnd = offset + size;
				if (sectionEnd > fileSize) {
					throw Exception(B_IO_ERROR, "Invalid ELF section header: "
						"section exceeds file: %lu.", sectionEnd);
				}
				resourceOffset = std::max(resourceOffset, sectionEnd);
			}
		}
	}

	// align the offset
	if (fileHeader.e_ident[EI_CLASS] == ELFCLASS64) {
		// For ELF64 binaries we use a different alignment behaviour. It is
		// not necessary to align the position of the resources in the file to
		// the maximum value of p_align, and in fact on x86_64 this behaviour
		// causes an undesirable effect: since the default segment alignment is
		// 2MB, aligning to p_align causes all binaries to be at least 2MB when
		// resources have been added. So, just align to an 8-byte boundary.
		resourceAlignment = 8;
	} else {
		// Retain previous alignment behaviour for compatibility.
		if (resourceAlignment < kELFMinResourceAlignment)
			resourceAlignment = kELFMinResourceAlignment;
		if (resourceAlignment > kELFMaxResourceAlignment) {
			throw Exception(B_IO_ERROR, "The ELF object file requires an "
				"invalid alignment: %lu.", resourceAlignment);
		}
	}

	resourceOffset = align_value(resourceOffset, resourceAlignment);
	if (resourceOffset >= fileSize) {
//		throw Exception("The ELF object file does not contain resources.");
		fEmptyResources = true;
	} else
		fEmptyResources = false;

	// fine, init the offset file
	fFile.SetTo(&file, resourceOffset);
}


void
ResourceFile::_InitPEFFile(BFile& file, const PEFContainerHeader& pefHeader)
{
	status_t error = B_OK;
	// get the file size
	off_t fileSize = 0;
	error = file.GetSize(&fileSize);
	if (error != B_OK)
		throw Exception(error, "Failed to get the file size.");
	// check architecture -- we support PPC only
	if (memcmp(pefHeader.architecture, kPEFArchitecturePPC, 4) != 0)
		throw Exception(B_IO_ERROR, "PEF file architecture is not PPC.");
	fHostEndianess = B_HOST_IS_BENDIAN;
	// get the section count
	uint16 sectionCount = _GetInt(pefHeader.sectionCount);
	// iterate through the PEF sections headers
	uint32 sectionHeaderTableOffset = kPEFContainerHeaderSize;
	uint32 sectionHeaderTableEnd
		= sectionHeaderTableOffset + sectionCount * kPEFSectionHeaderSize;
	uint32 resourceOffset = sectionHeaderTableEnd;
	for (int32 i = 0; i < (int32)sectionCount; i++) {
		uint32 shOffset = sectionHeaderTableOffset + i * kPEFSectionHeaderSize;
		PEFSectionHeader sectionHeader;
		read_exactly(file, shOffset, &sectionHeader, kPEFSectionHeaderSize,
			"Failed to read PEF section header.");
		// get the header values
		uint32 offset	= _GetInt(sectionHeader.containerOffset);
		uint32 size		= _GetInt(sectionHeader.packedSize);
		// check the values
		if (offset < sectionHeaderTableEnd || offset > fileSize) {
			throw Exception(B_IO_ERROR, "Invalid PEF section header: invalid "
				"section offset: %" B_PRIu32 ".", offset);
		}
		uint32 sectionEnd = offset + size;
		if (sectionEnd > fileSize) {
			throw Exception(B_IO_ERROR, "Invalid PEF section header: section "
				"exceeds file: %" B_PRIu32 ".", sectionEnd);
		}
		resourceOffset = std::max(resourceOffset, sectionEnd);
	}
	if (resourceOffset >= fileSize) {
//		throw Exception("The PEF object file does not contain resources.");
		fEmptyResources = true;
	} else
		fEmptyResources = false;
	// init the offset file
	fFile.SetTo(&file, resourceOffset);
}


void
ResourceFile::_ReadHeader(resource_parse_info& parseInfo)
{
	// read the header
	resources_header header;
	read_exactly(fFile, 0, &header, kResourcesHeaderSize,
		"Failed to read the header.");
	// check the header
	// magic
	uint32 magic = _GetInt(header.rh_resources_magic);
	if (magic == kResourcesHeaderMagic) {
		// everything is fine
	} else if (B_SWAP_INT32(magic) == kResourcesHeaderMagic) {
//		const char* endianessStr[2] = { "little", "big" };
//		int32 endianess
//			= (fHostEndianess == ((bool)B_HOST_IS_LENDIAN ? 0 : 1));
//		Warnings::AddCurrentWarning("Endianess seems to be %s, although %s "
//									"was expected.",
//									endianessStr[1 - endianess],
//									endianessStr[endianess]);
		fHostEndianess = !fHostEndianess;
	} else
		throw Exception(B_IO_ERROR, "Invalid resources header magic.");
	// resource count
	uint32 resourceCount = _GetInt(header.rh_resource_count);
	if (resourceCount > kMaxResourceCount)
		throw Exception(B_IO_ERROR, "Bad number of resources.");
	// index section offset
	uint32 indexSectionOffset = _GetInt(header.rh_index_section_offset);
	if (indexSectionOffset != kResourceIndexSectionOffset) {
		throw Exception(B_IO_ERROR, "Unexpected resource index section "
			"offset. Is: %" B_PRIu32 ", should be: %" B_PRIu32 ".",
			indexSectionOffset, kResourceIndexSectionOffset);
	}
	// admin section size
	uint32 indexSectionSize = kResourceIndexSectionHeaderSize
							  + kResourceIndexEntrySize * resourceCount;
	indexSectionSize = align_value(indexSectionSize,
								   kResourceIndexSectionAlignment);
	uint32 adminSectionSize = _GetInt(header.rh_admin_section_size);
	if (adminSectionSize != indexSectionOffset + indexSectionSize) {
		throw Exception(B_IO_ERROR, "Unexpected resource admin section size. "
			"Is: %" B_PRIu32 ", should be: %" B_PRIu32 ".", adminSectionSize,
			indexSectionOffset + indexSectionSize);
	}
	// set the resource count
	parseInfo.resource_count = resourceCount;
}


void
ResourceFile::_ReadIndex(resource_parse_info& parseInfo)
{
	int32& resourceCount = parseInfo.resource_count;
	off_t& fileSize = parseInfo.file_size;
	BBufferIO buffer(&fFile, 2048, false);

	// read the header
	resource_index_section_header header;
	read_exactly(buffer, kResourceIndexSectionOffset, &header,
		kResourceIndexSectionHeaderSize,
		"Failed to read the resource index section header.");
	// check the header
	// index section offset
	uint32 indexSectionOffset = _GetInt(header.rish_index_section_offset);
	if (indexSectionOffset != kResourceIndexSectionOffset) {
		throw Exception(B_IO_ERROR, "Unexpected resource index section "
			"offset. Is: %" B_PRIu32 ", should be: %" B_PRIu32 ".",
			indexSectionOffset, kResourceIndexSectionOffset);
	}
	// index section size
	uint32 expectedIndexSectionSize = kResourceIndexSectionHeaderSize
		+ kResourceIndexEntrySize * resourceCount;
	expectedIndexSectionSize = align_value(expectedIndexSectionSize,
										   kResourceIndexSectionAlignment);
	uint32 indexSectionSize = _GetInt(header.rish_index_section_size);
	if (indexSectionSize != expectedIndexSectionSize) {
		throw Exception(B_IO_ERROR, "Unexpected resource index section size. "
			"Is: %" B_PRIu32 ", should be: %" B_PRIu32 ".", indexSectionSize,
			expectedIndexSectionSize);
	}
	// unknown section offset
	uint32 unknownSectionOffset
		= _GetInt(header.rish_unknown_section_offset);
	if (unknownSectionOffset != indexSectionOffset + indexSectionSize) {
		throw Exception(B_IO_ERROR, "Unexpected resource index section size. "
			"Is: %" B_PRIu32 ", should be: %" B_PRIu32 ".",
			unknownSectionOffset, indexSectionOffset + indexSectionSize);
	}
	// unknown section size
	uint32 unknownSectionSize = _GetInt(header.rish_unknown_section_size);
	if (unknownSectionSize != kUnknownResourceSectionSize) {
		throw Exception(B_IO_ERROR, "Unexpected resource index section "
			"offset. Is: %" B_PRIu32 ", should be: %" B_PRIu32 ".",
			unknownSectionOffset, kUnknownResourceSectionSize);
	}

	// info table offset and size
	uint32 infoTableOffset = _GetInt(header.rish_info_table_offset);
	uint32 infoTableSize = _GetInt(header.rish_info_table_size);
	if (infoTableOffset + infoTableSize > fileSize)
		throw Exception(B_IO_ERROR, "Invalid info table location.");
	parseInfo.info_table_offset = infoTableOffset;
	parseInfo.info_table_size = infoTableSize;

	// read the index entries
	uint32 indexTableOffset = indexSectionOffset
		+ kResourceIndexSectionHeaderSize;
	int32 maxResourceCount = (unknownSectionOffset - indexTableOffset)
		/ kResourceIndexEntrySize;
	int32 actualResourceCount = 0;
	bool tableEndReached = false;
	for (int32 i = 0; !tableEndReached && i < maxResourceCount; i++) {
		// read one entry
		tableEndReached = !_ReadIndexEntry(buffer, parseInfo, i,
			indexTableOffset, (i >= resourceCount));
		if (!tableEndReached)
			actualResourceCount++;
	}
	// check resource count
	if (actualResourceCount != resourceCount) {
		if (actualResourceCount > resourceCount) {
//			Warnings::AddCurrentWarning("Resource index table contains "
//										"%ld entries, although it should be "
//										"%ld only.", actualResourceCount,
//										resourceCount);
		}
		resourceCount = actualResourceCount;
	}
}


bool
ResourceFile::_ReadIndexEntry(BPositionIO& buffer,
	resource_parse_info& parseInfo, int32 index, uint32 tableOffset,
	bool peekAhead)
{
	off_t& fileSize = parseInfo.file_size;
	bool result = true;
	resource_index_entry entry;

	// read one entry
	off_t entryOffset = tableOffset + index * kResourceIndexEntrySize;
	read_exactly(buffer, entryOffset, &entry, kResourceIndexEntrySize,
		"Failed to read a resource index entry.");

	// check, if the end is reached early
	if (result && check_pattern(entryOffset, &entry,
			kResourceIndexEntrySize / 4, fHostEndianess)) {
		result = false;
	}
	uint32 offset = _GetInt(entry.rie_offset);
	uint32 size = _GetInt(entry.rie_size);

	// check the location
	if (result && offset + size > fileSize) {
		if (!peekAhead) {
			throw Exception(B_IO_ERROR, "Invalid resource index entry: index: "
				"%" B_PRId32 ", offset: %" B_PRIu32 " (%" B_PRIx32 "), "
				"size: %" B_PRIu32 " (%" B_PRIx32 ").",
				index + 1, offset, offset, size, size);
		}
		result = false;
	}

	// add the entry
	if (result) {
		ResourceItem* item = new(std::nothrow) ResourceItem;
		if (!item)
			throw Exception(B_NO_MEMORY);
		item->SetLocation(offset, size);
		if (!parseInfo.container->AddResource(item, index, false)) {
			delete item;
			throw Exception(B_NO_MEMORY);
		}
	}

	return result;
}


void
ResourceFile::_ReadInfoTable(resource_parse_info& parseInfo)
{
	int32& resourceCount = parseInfo.resource_count;
	// read the info table
	// alloc memory for the table
	char* tableData = new(std::nothrow) char[parseInfo.info_table_size];
	if (!tableData)
		throw Exception(B_NO_MEMORY);
	int32 dataSize = parseInfo.info_table_size;
	parseInfo.info_table = tableData;	// freed by the info owner
	read_exactly(fFile, parseInfo.info_table_offset, tableData, dataSize,
		"Failed to read resource info table.");
	//
	bool* readIndices = new(std::nothrow) bool[resourceCount + 1];
		// + 1 => always > 0
	if (!readIndices)
		throw Exception(B_NO_MEMORY);
	ArrayDeleter<bool> readIndicesDeleter(readIndices);
	for (int32 i = 0; i < resourceCount; i++)
		readIndices[i] = false;
	MemArea area(tableData, dataSize);
	const void* data = tableData;
	// check the table end/check sum
	if (_ReadInfoTableEnd(data, dataSize))
		dataSize -= kResourceInfoTableEndSize;
	// read the infos
	int32 resourceIndex = 1;
	uint32 minRemainderSize
		= kMinResourceInfoBlockSize + kResourceInfoSeparatorSize;
	while (area.check(data, minRemainderSize)) {
		// read a resource block
		if (!area.check(data, kMinResourceInfoBlockSize)) {
			throw Exception(B_IO_ERROR, "Unexpected end of resource info "
				"table at index %" B_PRId32 ".", resourceIndex);
		}
		const resource_info_block* infoBlock
			= (const resource_info_block*)data;
		type_code type = _GetInt(infoBlock->rib_type);
		// read the infos of this block
		const resource_info* info = infoBlock->rib_info;
		while (info) {
			data = _ReadResourceInfo(parseInfo, area, info, type, readIndices);
			// prepare for next iteration, if there is another info
			if (!area.check(data, kResourceInfoSeparatorSize)) {
				throw Exception(B_IO_ERROR, "Unexpected end of resource info "
					"table after index %" B_PRId32 ".", resourceIndex);
			}
			const resource_info_separator* separator
				= (const resource_info_separator*)data;
			if (_GetInt(separator->ris_value1) == 0xffffffff
				&& _GetInt(separator->ris_value2) == 0xffffffff) {
				// info block ends
				info = NULL;
				data = skip_bytes(data, kResourceInfoSeparatorSize);
			} else {
				// another info follows
				info = (const resource_info*)data;
			}
			resourceIndex++;
		}
		// end of the info block
	}
	// handle special case: empty resource info table
	if (resourceIndex == 1) {
		if (!area.check(data, kResourceInfoSeparatorSize)) {
			throw Exception(B_IO_ERROR, "Unexpected end of resource info "
				"table.");
		}
		const resource_info_separator* tableTerminator
			= (const resource_info_separator*)data;
		if (_GetInt(tableTerminator->ris_value1) != 0xffffffff
			|| _GetInt(tableTerminator->ris_value2) != 0xffffffff) {
			throw Exception(B_IO_ERROR, "The resource info table ought to be "
				"empty, but is not properly terminated.");
		}
		data = skip_bytes(data, kResourceInfoSeparatorSize);
	}
	// Check, if the correct number of bytes are remaining.
	uint32 bytesLeft = (const char*)tableData + dataSize - (const char*)data;
	if (bytesLeft != 0) {
		throw Exception(B_IO_ERROR, "Error at the end of the resource info "
			"table: %" B_PRIu32 " bytes are remaining.", bytesLeft);
	}
	// check, if all items have been initialized
	for (int32 i = resourceCount - 1; i >= 0; i--) {
		if (!readIndices[i]) {
//			Warnings::AddCurrentWarning("Resource item at index %ld "
//										"has no info. Item removed.", i + 1);
			if (ResourceItem* item = parseInfo.container->RemoveResource(i))
				delete item;
			resourceCount--;
		}
	}
}


bool
ResourceFile::_ReadInfoTableEnd(const void* data, int32 dataSize)
{
	bool hasTableEnd = true;
	if ((uint32)dataSize < kResourceInfoSeparatorSize)
		throw Exception(B_IO_ERROR, "Info table is too short.");
	if ((uint32)dataSize < kResourceInfoTableEndSize)
		hasTableEnd = false;
	if (hasTableEnd) {
		const resource_info_table_end* tableEnd
			= (const resource_info_table_end*)
			  skip_bytes(data, dataSize - kResourceInfoTableEndSize);
		if (_GetInt(tableEnd->rite_terminator) != 0)
			hasTableEnd = false;
		if (hasTableEnd) {
			dataSize -= kResourceInfoTableEndSize;
			// checksum
			uint32 checkSum = calculate_checksum(data, dataSize);
			uint32 fileCheckSum = _GetInt(tableEnd->rite_check_sum);
			if (checkSum != fileCheckSum) {
				throw Exception(B_IO_ERROR, "Invalid resource info table check"
					" sum: In file: %" B_PRIx32 ", calculated: %" B_PRIx32 ".",
					fileCheckSum, checkSum);
			}
		}
	}
//	if (!hasTableEnd)
//		Warnings::AddCurrentWarning("resource info table has no check sum.");
	return hasTableEnd;
}


const void*
ResourceFile::_ReadResourceInfo(resource_parse_info& parseInfo,
	const MemArea& area, const resource_info* info, type_code type,
	bool* readIndices)
{
	int32& resourceCount = parseInfo.resource_count;
	int32 id = _GetInt(info->ri_id);
	int32 index = _GetInt(info->ri_index);
	uint16 nameSize = _GetInt(info->ri_name_size);
	const char* name = info->ri_name;
	// check the values
	bool ignore = false;
	// index
	if (index < 1 || index > resourceCount) {
//		Warnings::AddCurrentWarning("Invalid index field in resource "
//									"info table: %lu.", index);
		ignore = true;
	}
	if (!ignore) {
		if (readIndices[index - 1]) {
			throw Exception(B_IO_ERROR, "Multiple resource infos with the "
				"same index field: %" B_PRId32 ".", index);
		}
		readIndices[index - 1] = true;
	}
	// name size
	if (!area.check(name, nameSize)) {
		throw Exception(B_IO_ERROR, "Invalid name size (%" B_PRIu16 ") "
			"for index %" B_PRId32 " in resource info table.",
			nameSize, index);
	}
	// check, if name is null terminated
	if (name[nameSize - 1] != 0) {
//		Warnings::AddCurrentWarning("Name for index %ld in "
//									"resource info table is not null "
//									"terminated.", index);
	}
	// set the values
	if (!ignore) {
		BString resourceName(name, nameSize);
		if (ResourceItem* item = parseInfo.container->ResourceAt(index - 1))
			item->SetIdentity(type, id, resourceName.String());
		else {
			throw Exception(B_IO_ERROR, "Unexpected error: No resource item "
				"at index %" B_PRId32 ".", index);
		}
	}
	return skip_bytes(name, nameSize);
}


status_t
ResourceFile::_WriteResources(ResourcesContainer& container)
{
	status_t error = B_OK;
	int32 resourceCount = container.CountResources();
	char* buffer = NULL;
	try {
		// calculate sizes and offsets
		// header
		uint32 size = kResourcesHeaderSize;
		size_t bufferSize = size;
		// index section
		uint32 indexSectionOffset = size;
		uint32 indexSectionSize = kResourceIndexSectionHeaderSize
			+ resourceCount * kResourceIndexEntrySize;
		indexSectionSize = align_value(indexSectionSize,
			kResourceIndexSectionAlignment);
		size += indexSectionSize;
		bufferSize = std::max((uint32)bufferSize, indexSectionSize);
		// unknown section
		uint32 unknownSectionOffset = size;
		uint32 unknownSectionSize = kUnknownResourceSectionSize;
		size += unknownSectionSize;
		bufferSize = std::max((uint32)bufferSize, unknownSectionSize);
		// data
		uint32 dataOffset = size;
		uint32 dataSize = 0;
		for (int32 i = 0; i < resourceCount; i++) {
			ResourceItem* item = container.ResourceAt(i);
			if (!item->IsLoaded())
				throw Exception(B_IO_ERROR, "Resource is not loaded.");
			dataSize += item->DataSize();
			bufferSize = std::max(bufferSize, item->DataSize());
		}
		size += dataSize;
		// info table
		uint32 infoTableOffset = size;
		uint32 infoTableSize = 0;
		type_code type = 0;
		for (int32 i = 0; i < resourceCount; i++) {
			ResourceItem* item = container.ResourceAt(i);
			if (i == 0 || type != item->Type()) {
				if (i != 0)
					infoTableSize += kResourceInfoSeparatorSize;
				type = item->Type();
				infoTableSize += kMinResourceInfoBlockSize;
			} else
				infoTableSize += kMinResourceInfoSize;

			const char* name = item->Name();
			if (name && name[0] != '\0')
				infoTableSize += strlen(name) + 1;
		}
		infoTableSize += kResourceInfoSeparatorSize
			+ kResourceInfoTableEndSize;
		size += infoTableSize;
		bufferSize = std::max((uint32)bufferSize, infoTableSize);

		// write...
		// set the file size
		fFile.SetSize(size);
		buffer = new(std::nothrow) char[bufferSize];
		if (!buffer)
			throw Exception(B_NO_MEMORY);
		void* data = buffer;
		// header
		resources_header* resourcesHeader = (resources_header*)data;
		resourcesHeader->rh_resources_magic = kResourcesHeaderMagic;
		resourcesHeader->rh_resource_count = resourceCount;
		resourcesHeader->rh_index_section_offset = indexSectionOffset;
		resourcesHeader->rh_admin_section_size = indexSectionOffset
												 + indexSectionSize;
		for (int32 i = 0; i < 13; i++)
			resourcesHeader->rh_pad[i] = 0;
		write_exactly(fFile, 0, buffer, kResourcesHeaderSize,
			"Failed to write resources header.");
		// index section
		data = buffer;
		// header
		resource_index_section_header* indexHeader
			= (resource_index_section_header*)data;
		indexHeader->rish_index_section_offset = indexSectionOffset;
		indexHeader->rish_index_section_size = indexSectionSize;
		indexHeader->rish_unknown_section_offset = unknownSectionOffset;
		indexHeader->rish_unknown_section_size = unknownSectionSize;
		indexHeader->rish_info_table_offset = infoTableOffset;
		indexHeader->rish_info_table_size = infoTableSize;
		fill_pattern(buffer - indexSectionOffset,
			&indexHeader->rish_unused_data1, 1);
		fill_pattern(buffer - indexSectionOffset,
			indexHeader->rish_unused_data2, 25);
		fill_pattern(buffer - indexSectionOffset,
			&indexHeader->rish_unused_data3, 1);
		// index table
		data = skip_bytes(data, kResourceIndexSectionHeaderSize);
		resource_index_entry* entry = (resource_index_entry*)data;
		uint32 entryOffset = dataOffset;
		for (int32 i = 0; i < resourceCount; i++, entry++) {
			ResourceItem* item = container.ResourceAt(i);
			uint32 entrySize = item->DataSize();
			entry->rie_offset = entryOffset;
			entry->rie_size = entrySize;
			entry->rie_pad = 0;
			entryOffset += entrySize;
		}
		fill_pattern(buffer - indexSectionOffset, entry,
			buffer + indexSectionSize);
		write_exactly(fFile, indexSectionOffset, buffer, indexSectionSize,
			"Failed to write index section.");
		// unknown section
		fill_pattern(unknownSectionOffset, buffer, unknownSectionSize / 4);
		write_exactly(fFile, unknownSectionOffset, buffer, unknownSectionSize,
			"Failed to write unknown section.");
		// data
		uint32 itemOffset = dataOffset;
		for (int32 i = 0; i < resourceCount; i++) {
			data = buffer;
			ResourceItem* item = container.ResourceAt(i);
			const void* itemData = item->Data();
			uint32 itemSize = item->DataSize();
			if (!itemData && itemSize > 0)
				throw Exception(error, "Invalid resource item data.");
			if (itemData) {
				// swap data, if necessary
				if (!fHostEndianess) {
					memcpy(data, itemData, itemSize);
					if (item->Type() == B_VERSION_INFO_TYPE) {
						// Version info contains integers
						// that need to be swapped
						swap_data(B_UINT32_TYPE, data,
							kVersionInfoIntCount * sizeof(uint32),
							B_SWAP_ALWAYS);
					} else
						swap_data(item->Type(), data, itemSize, B_SWAP_ALWAYS);
					itemData = data;
				}
				write_exactly(fFile, itemOffset, itemData, itemSize,
					"Failed to write resource item data.");
			}
			item->SetOffset(itemOffset);
			itemOffset += itemSize;
		}
		// info table
		data = buffer;
		type = 0;
		for (int32 i = 0; i < resourceCount; i++) {
			ResourceItem* item = container.ResourceAt(i);
			resource_info* info = NULL;
			if (i == 0 || type != item->Type()) {
				if (i != 0) {
					resource_info_separator* separator
						= (resource_info_separator*)data;
					separator->ris_value1 = 0xffffffff;
					separator->ris_value2 = 0xffffffff;
					data = skip_bytes(data, kResourceInfoSeparatorSize);
				}
				type = item->Type();
				resource_info_block* infoBlock = (resource_info_block*)data;
				infoBlock->rib_type = type;
				info = infoBlock->rib_info;
			} else
				info = (resource_info*)data;
			// info
			info->ri_id = item->ID();
			info->ri_index = i + 1;
			info->ri_name_size = 0;
			data = info->ri_name;

			const char* name = item->Name();
			if (name && name[0] != '\0') {
				uint32 nameLen = strlen(name);
				memcpy(info->ri_name, name, nameLen + 1);
				data = skip_bytes(data, nameLen + 1);
				info->ri_name_size = nameLen + 1;
			}
		}
		// separator
		resource_info_separator* separator = (resource_info_separator*)data;
		separator->ris_value1 = 0xffffffff;
		separator->ris_value2 = 0xffffffff;
		// table end
		data = skip_bytes(data, kResourceInfoSeparatorSize);
		resource_info_table_end* tableEnd = (resource_info_table_end*)data;
		tableEnd->rite_check_sum = calculate_checksum(buffer,
			infoTableSize - kResourceInfoTableEndSize);
		tableEnd->rite_terminator = 0;
		write_exactly(fFile, infoTableOffset, buffer, infoTableSize,
			"Failed to write info table.");
	} catch (Exception& exception) {
		if (exception.Error() != B_OK)
			error = exception.Error();
		else
			error = B_ERROR;
	}
	delete[] buffer;
	return error;
}


status_t
ResourceFile::_MakeEmptyResourceFile()
{
	status_t error = fFile.InitCheck();
	if (error == B_OK && !fFile.File()->IsWritable())
		error = B_NOT_ALLOWED;
	if (error == B_OK) {
		try {
			BFile* file = fFile.File();
			// make it an x86 resource file
			error = file->SetSize(4);
			if (error != B_OK)
				throw Exception(error, "Failed to set file size.");
			write_exactly(*file, 0, kX86ResourceFileMagic, 4,
				"Failed to write magic number.");
			fHostEndianess = B_HOST_IS_LENDIAN;
			fFileType = FILE_TYPE_X86_RESOURCE;
			fFile.SetTo(file, kX86ResourcesOffset);
			fEmptyResources = true;
		} catch (Exception& exception) {
			if (exception.Error() != B_OK)
				error = exception.Error();
			else
				error = B_ERROR;
		}
	}
	return error;
}


};	// namespace Storage
};	// namespace BPrivate