xref: /haiku/src/tools/restest/ResourceFile.cpp (revision b55a57da7173b9af0432bd3e148d03f06161d036) 
1 // ResourceFile.cpp
2 
3 #include "ResourceFile.h"
4 
5 #include <algobase.h>
6 #include <stdio.h>
7 
8 #include "Elf.h"
9 #include "Exception.h"
10 #include "Pef.h"
11 #include "ResourceItem.h"
12 #include "ResourcesDefs.h"
13 #include "Warnings.h"
14 
15 // ELF defs
16 static const uint32	kMaxELFHeaderSize			= sizeof(Elf32_Ehdr) + 32;
17 static const char	kELFFileMagic[4]			= { 0x7f, 'E', 'L', 'F' };
18 
19 // sanity bounds
20 static const uint32	kMaxResourceCount			= 10000;
21 static const uint32	kELFMaxResourceAlignment	= 1024 * 1024 * 10;	// 10 MB
22 
23 // recognized file types (indices into kFileTypeNames)
24 enum {
25 	FILE_TYPE_UNKNOWN		= 0,
26 	FILE_TYPE_X86_RESOURCE	= 1,
27 	FILE_TYPE_PPC_RESOURCE	= 2,
28 	FILE_TYPE_ELF			= 3,
29 	FILE_TYPE_PEF			= 4,
30 };
31 
32 const char* kFileTypeNames[] = {
33 	"unknown",
34 	"x86 resource file",
35 	"PPC resource file",
36 	"ELF object file",
37 	"PEF object file",
38 };
39 
40 
41 // helper functions/classes
42 
43 // read_exactly
44 static
45 void
46 read_exactly(BPositionIO& file, off_t position, void* buffer, size_t size,
47 			 const char* errorMessage = NULL)
48 {
49 	ssize_t read = file.ReadAt(position, buffer, size);
50 	if (read < 0)
51 		throw Exception(read, errorMessage);
52 	else if ((size_t)read != size) {
53 		if (errorMessage) {
54 			throw Exception("%s Read to few bytes (%ld/%lu).", errorMessage,
55 							read, size);
56 		} else
57 			throw Exception("Read to few bytes (%ld/%lu).", read, size);
58 	}
59 }
60 
61 // align_value
62 template<typename TV, typename TA>
63 static inline
64 TV
65 align_value(const TV& value, const TA& alignment)
66 {
67 	return ((value + alignment - 1) / alignment) * alignment;
68 }
69 
70 // calculate_checksum
71 static
72 uint32
73 calculate_checksum(const void* data, uint32 size)
74 {
75 	uint32 checkSum = 0;
76 	const uint8* csData = (const uint8*)data;
77 	const uint8* dataEnd = csData + size;
78 	const uint8* current = csData;
79 	for (; current < dataEnd; current += 4) {
80 		uint32 word = 0;
81 		int32 bytes = min(4L, dataEnd - current);
82 		for (int32 i = 0; i < bytes; i++)
83 			word = (word << 8) + current[i];
84 		checkSum += word;
85 	}
86 	return checkSum;
87 }
88 
89 // skip_bytes
90 static inline
91 const void*
92 skip_bytes(const void* buffer, int32 offset)
93 {
94 	return (const char*)buffer + offset;
95 }
96 
97 // skip_bytes
98 static inline
99 void*
100 skip_bytes(void* buffer, int32 offset)
101 {
102 	return (char*)buffer + offset;
103 }
104 
105 // fill_pattern
106 static
107 void
108 fill_pattern(uint32 byteOffset, void* _buffer, uint32 count)
109 {
110 	uint32* buffer = (uint32*)_buffer;
111 	for (uint32 i = 0; i < count; i++)
112 		buffer[i] = kUnusedResourceDataPattern[(byteOffset / 4 + i) % 3];
113 }
114 
115 // fill_pattern
116 static
117 void
118 fill_pattern(const void* dataBegin, void* buffer, uint32 count)
119 {
120 	fill_pattern((char*)buffer - (const char*)dataBegin, buffer, count);
121 }
122 
123 // fill_pattern
124 static
125 void
126 fill_pattern(const void* dataBegin, void* buffer, const void* bufferEnd)
127 {
128 	fill_pattern(dataBegin, buffer,
129 				 ((const char*)bufferEnd - (char*)buffer) / 4);
130 }
131 
132 // check_pattern
133 static
134 bool
135 check_pattern(uint32 byteOffset, void* _buffer, uint32 count,
136 			  bool hostEndianess)
137 {
138 	bool result = true;
139 	uint32* buffer = (uint32*)_buffer;
140 	for (uint32 i = 0; result && i < count; i++) {
141 		uint32 value = buffer[i];
142 		if (!hostEndianess)
143 			value = B_SWAP_INT32(value);
144 		result
145 			= (value == kUnusedResourceDataPattern[(byteOffset / 4 + i) % 3]);
146 	}
147 	return result;
148 }
149 
150 // MemArea
151 struct MemArea {
152 	MemArea(const void* data, uint32 size) : data(data), size(size) {}
153 
154 	inline bool check(const void* _current, uint32 skip = 0) const
155 	{
156 		const char* start = (const char*)data;
157 		const char* current = (const char*)_current;
158 		return (start <= current && start + size >= current + skip);
159 	}
160 
161 	const void*	data;
162 	uint32		size;
163 };
164 
165 // AutoDeleter
166 template<typename C>
167 struct AutoDeleter {
168 	AutoDeleter(C* object, bool array = false) : object(object), array(array)
169 	{
170 	}
171 
172 	~AutoDeleter()
173 	{
174 		if (array)
175 			delete[] object;
176 		else
177 			delete object;
178 	}
179 
180 	C*		object;
181 	bool	array;
182 };
183 
184 
185 // constructor
186 ResourceFile::ResourceFile()
187 			: fItems(),
188 			  fFile(),
189 			  fFileType(FILE_TYPE_UNKNOWN),
190 			  fFileSize(0),
191 			  fResourceCount(0),
192 			  fInfoTableItem(NULL),
193 			  fHostEndianess(true)
194 {
195 }
196 
197 // destructor
198 ResourceFile::~ResourceFile()
199 {
200 	Unset();
201 }
202 
203 // Init
204 void
205 ResourceFile::Init(BFile& file)
206 {
207 	Unset();
208 	try {
209 		_InitFile(file);
210 		_ReadHeader();
211 		_ReadIndex();
212 		_ReadInfoTable();
213 	} catch (Exception exception) {
214 		Unset();
215 		throw exception;
216 	}
217 }
218 
219 // Unset
220 void
221 ResourceFile::Unset()
222 {
223 	// items
224 	for (int32 i = 0; ResourceItem* item = ItemAt(i); i++)
225 		delete item;
226 	fItems.MakeEmpty();
227 	// file
228 	fFile.Unset();
229 	fFileType = FILE_TYPE_UNKNOWN;
230 	fFileSize = 0;
231 	// resource count
232 	fResourceCount = 0;
233 	// info table
234 	delete fInfoTableItem;
235 	fInfoTableItem = NULL;
236 	fHostEndianess = true;
237 }
238 
239 // InitCheck
240 status_t
241 ResourceFile::InitCheck() const
242 {
243 	return fFile.InitCheck();
244 }
245 
246 // AddItem
247 bool
248 ResourceFile::AddItem(ResourceItem* item, int32 index)
249 {
250 	bool result = false;
251 	if (item) {
252 		if (index < 0 || index > CountItems())
253 			index = CountItems();
254 		result = fItems.AddItem(item);
255 	}
256 	return result;
257 }
258 
259 // RemoveItem
260 ResourceItem*
261 ResourceFile::RemoveItem(int32 index)
262 {
263 	return (ResourceItem*)fItems.RemoveItem(index);
264 }
265 
266 // RemoveItem
267 bool
268 ResourceFile::RemoveItem(ResourceItem* item)
269 {
270 	return RemoveItem(IndexOf(item));
271 }
272 
273 // IndexOf
274 int32
275 ResourceFile::IndexOf(ResourceItem* item) const
276 {
277 	return fItems.IndexOf(item);
278 }
279 
280 // ItemAt
281 ResourceItem*
282 ResourceFile::ItemAt(int32 index) const
283 {
284 	return (ResourceItem*)fItems.ItemAt(index);
285 }
286 
287 // CountItems
288 int32
289 ResourceFile::CountItems() const
290 {
291 	return fItems.CountItems();
292 }
293 
294 // GetResourcesSize
295 uint32
296 ResourceFile::GetResourcesSize() const
297 {
298 	if (!fInfoTableItem || fFile.InitCheck())
299 		throw Exception("Resource file not initialized.");
300 	// header
301 	uint32 size = kResourcesHeaderSize;
302 	// index section
303 	uint32 indexSectionSize = kResourceIndexSectionHeaderSize
304 		+ fResourceCount * kResourceIndexEntrySize;
305 	indexSectionSize = align_value(indexSectionSize,
306 								   kResourceIndexSectionAlignment);
307 	size += indexSectionSize;
308 	// unknown section
309 	size += kUnknownResourceSectionSize;
310 	// data
311 	uint32 dataSize = 0;
312 	for (int32 i = 0; i < fResourceCount; i++) {
313 		ResourceItem* item = ItemAt(i);
314 		dataSize += item->GetSize();
315 	}
316 	size += dataSize;
317 	// info table
318 	uint32 infoTableSize = 0;
319 	type_code type = 0;
320 	for (int32 i = 0; i < fResourceCount; i++) {
321 		ResourceItem* item = ItemAt(i);
322 		if (i == 0 || type != item->GetType()) {
323 			if (i != 0)
324 				infoTableSize += kResourceInfoSeparatorSize;
325 			type = item->GetType();
326 			infoTableSize += kMinResourceInfoBlockSize;
327 		} else
328 			infoTableSize += kMinResourceInfoSize;
329 		uint32 nameLen = strlen(item->GetName());
330 		if (nameLen != 0)
331 			infoTableSize += nameLen + 1;
332 	}
333 	infoTableSize += kResourceInfoSeparatorSize + kResourceInfoTableEndSize;
334 	size += infoTableSize;
335 	return size;
336 }
337 
338 // WriteResources
339 uint32
340 ResourceFile::WriteResources(void* buffer, uint32 bufferSize)
341 {
342 	// calculate sizes and offsets
343 	// header
344 	uint32 size = kResourcesHeaderSize;
345 	// index section
346 	uint32 indexSectionOffset = size;
347 	uint32 indexSectionSize = kResourceIndexSectionHeaderSize
348 		+ fResourceCount * kResourceIndexEntrySize;
349 	indexSectionSize = align_value(indexSectionSize,
350 								   kResourceIndexSectionAlignment);
351 	size += indexSectionSize;
352 	// unknown section
353 	uint32 unknownSectionOffset = size;
354 	uint32 unknownSectionSize = kUnknownResourceSectionSize;
355 	size += unknownSectionSize;
356 	// data
357 	uint32 dataOffset = size;
358 	uint32 dataSize = 0;
359 	for (int32 i = 0; i < fResourceCount; i++) {
360 		ResourceItem* item = ItemAt(i);
361 		dataSize += item->GetSize();
362 	}
363 	size += dataSize;
364 	// info table
365 	uint32 infoTableOffset = size;
366 	uint32 infoTableSize = 0;
367 	type_code type = 0;
368 	for (int32 i = 0; i < fResourceCount; i++) {
369 		ResourceItem* item = ItemAt(i);
370 		if (i == 0 || type != item->GetType()) {
371 			if (i != 0)
372 				infoTableSize += kResourceInfoSeparatorSize;
373 			type = item->GetType();
374 			infoTableSize += kMinResourceInfoBlockSize;
375 		} else
376 			infoTableSize += kMinResourceInfoSize;
377 		uint32 nameLen = strlen(item->GetName());
378 		if (nameLen != 0)
379 			infoTableSize += nameLen + 1;
380 	}
381 	infoTableSize += kResourceInfoSeparatorSize + kResourceInfoTableEndSize;
382 	size += infoTableSize;
383 	// check whether the buffer is large enough
384 	if (!buffer)
385 		throw Exception("Supplied buffer is NULL.");
386 	if (bufferSize < size)
387 		throw Exception("Supplied buffer is too small.");
388 	// write...
389 	void* data = buffer;
390 	// header
391 	resources_header* resourcesHeader = (resources_header*)data;
392 	resourcesHeader->rh_resources_magic = kResourcesHeaderMagic;
393 	resourcesHeader->rh_resource_count = fResourceCount;
394 	resourcesHeader->rh_index_section_offset = indexSectionOffset;
395 	resourcesHeader->rh_admin_section_size = indexSectionOffset
396 											 + indexSectionSize;
397 	for (int32 i = 0; i < 13; i++)
398 		resourcesHeader->rh_pad[i] = 0;
399 	// index section
400 	// header
401 	data = skip_bytes(buffer, indexSectionOffset);
402 	resource_index_section_header* indexHeader
403 		= (resource_index_section_header*)data;
404 	indexHeader->rish_index_section_offset = indexSectionOffset;
405 	indexHeader->rish_index_section_size = indexSectionSize;
406 	indexHeader->rish_unknown_section_offset = unknownSectionOffset;
407 	indexHeader->rish_unknown_section_size = unknownSectionSize;
408 	indexHeader->rish_info_table_offset = infoTableOffset;
409 	indexHeader->rish_info_table_size = infoTableSize;
410 	fill_pattern(buffer, &indexHeader->rish_unused_data1, 1);
411 	fill_pattern(buffer, indexHeader->rish_unused_data2, 25);
412 	fill_pattern(buffer, &indexHeader->rish_unused_data3, 1);
413 	// index table
414 	data = skip_bytes(data, kResourceIndexSectionHeaderSize);
415 	resource_index_entry* entry = (resource_index_entry*)data;
416 	uint32 entryOffset = dataOffset;
417 	for (int32 i = 0; i < fResourceCount; i++, entry++) {
418 		ResourceItem* item = ItemAt(i);
419 		uint32 entrySize = item->GetSize();
420 		entry->rie_offset = entryOffset;
421 		entry->rie_size = entrySize;
422 		entry->rie_pad = 0;
423 		entryOffset += entrySize;
424 	}
425 	// padding + unknown section
426 	data = skip_bytes(buffer, dataOffset);
427 	fill_pattern(buffer, entry, data);
428 	// data
429 	for (int32 i = 0; i < fResourceCount; i++) {
430 		ResourceItem* item = ItemAt(i);
431 		status_t error = item->LoadData(fFile);
432 		if (error != B_OK)
433 			throw Exception(error, "Error loading resource data.");
434 		uint32 entrySize = item->GetSize();
435 		memcpy(data, item->GetData(), entrySize);
436 		data = skip_bytes(data, entrySize);
437 	}
438 	// info table
439 	data = skip_bytes(buffer, infoTableOffset);
440 	type = 0;
441 	for (int32 i = 0; i < fResourceCount; i++) {
442 		ResourceItem* item = ItemAt(i);
443 		resource_info* info = NULL;
444 		if (i == 0 || type != item->GetType()) {
445 			if (i != 0) {
446 				resource_info_separator* separator
447 					= (resource_info_separator*)data;
448 				separator->ris_value1 = 0xffffffff;
449 				separator->ris_value2 = 0xffffffff;
450 				data = skip_bytes(data, kResourceInfoSeparatorSize);
451 			}
452 			type = item->GetType();
453 			resource_info_block* infoBlock = (resource_info_block*)data;
454 			infoBlock->rib_type = type;
455 			info = infoBlock->rib_info;
456 		} else
457 			info = (resource_info*)data;
458 		// info
459 		info->ri_id = item->GetID();
460 		info->ri_index = i + 1;
461 		info->ri_name_size = 0;
462 		data = info->ri_name;
463 		uint32 nameLen = strlen(item->GetName());
464 		if (nameLen != 0) {
465 			memcpy(info->ri_name, item->GetName(), nameLen + 1);
466 			data = skip_bytes(data, nameLen + 1);
467 			info->ri_name_size = nameLen + 1;
468 		}
469 	}
470 	// separator
471 	resource_info_separator* separator = (resource_info_separator*)data;
472 	separator->ris_value1 = 0xffffffff;
473 	separator->ris_value2 = 0xffffffff;
474 	// table end
475 	data = skip_bytes(data, kResourceInfoSeparatorSize);
476 	resource_info_table_end* tableEnd = (resource_info_table_end*)data;
477 	void* infoTable = skip_bytes(buffer, infoTableOffset);
478 	tableEnd->rite_check_sum = calculate_checksum(infoTable,
479 		infoTableSize - kResourceInfoTableEndSize);
480 	tableEnd->rite_terminator = 0;
481 	// final check
482 	data = skip_bytes(data, kResourceInfoTableEndSize);
483 	uint32 bytesWritten = (char*)data - (char*)buffer;
484 	if (bytesWritten != size) {
485 		throw Exception("Bad boy error: Wrote %lu bytes, though supposed to "
486 						"write %lu bytes.", bytesWritten, size);
487 	}
488 	return size;
489 }
490 
491 // WriteTest
492 void
493 ResourceFile::WriteTest()
494 {
495 	uint32 size = GetResourcesSize();
496 	if (size != fFileSize) {
497 		throw Exception("Calculated resources size differs from actual size "
498 						"in file: %lu vs %Ld.", size, fFileSize);
499 	}
500 	char* buffer1 = new char[size];
501 	char* buffer2 = new char[size];
502 	try {
503 		WriteResources(buffer1, size);
504 		read_exactly(fFile, 0, buffer2, size,
505 					 "Write test: Error reading resources.");
506 		for (uint32 i = 0; i < size; i++) {
507 			if (buffer1[i] != buffer2[i]) {
508 				off_t filePosition = fFile.GetOffset() + i;
509 				throw Exception("Written resources differ from those in file. "
510 								"First difference at byte %lu (file position "
511 								"%Ld): %x vs %x.", i, filePosition,
512 								(int)buffer1[i] & 0xff,
513 								(int)buffer2[i] & 0xff);
514 			}
515 		}
516 	} catch (Exception exception) {
517 		delete[] buffer1;
518 		delete[] buffer2;
519 		throw exception;
520 	}
521 	delete[] buffer1;
522 	delete[] buffer2;
523 }
524 
525 
526 
527 // PrintToStream
528 void
529 ResourceFile::PrintToStream(bool longInfo)
530 {
531 	if (longInfo) {
532 		off_t resourcesOffset = fFile.GetOffset();
533 		printf("ResourceFile:\n");
534 		printf("file type              : %s\n", kFileTypeNames[fFileType]);
535 		printf("endianess              : %s\n",
536 			   (fHostEndianess == (bool)B_HOST_IS_LENDIAN) ? "little" : "big");
537 		printf("resource section offset: 0x%08Lx (%Ld)\n", resourcesOffset,
538 			   resourcesOffset);
539 		if (fInfoTableItem) {
540 			int32 offset = fInfoTableItem->GetOffset();
541 			int32 size = fInfoTableItem->GetSize();
542 			printf("resource info table    : offset: 0x%08lx (%ld), "
543 				   "size: 0x%08lx (%ld)\n", offset, offset, size, size);
544 		}
545 		printf("number of resources    : %ld\n", fResourceCount);
546 		for (int32 i = 0; i < fResourceCount; i++) {
547 			ResourceItem* item = ItemAt(i);
548 			item->PrintToStream();
549 		}
550 	} else {
551 		printf("   Type     ID     Size  Name\n");
552 		printf("  ------ ----- --------  --------------------\n");
553 		for (int32 i = 0; i < fResourceCount; i++) {
554 			ResourceItem* item = ItemAt(i);
555 			type_code type = item->GetType();
556 			char typeName[4] = { type >> 24, (type >> 16) & 0xff,
557 								 (type >> 8) & 0xff, type & 0xff };
558 			printf("  '%.4s' %5ld %8lu  %s\n", typeName, item->GetID(),
559 				   item->GetSize(), item->GetName());
560 		}
561 	}
562 }
563 
564 
565 // _InitFile
566 void
567 ResourceFile::_InitFile(BFile& file)
568 {
569 	status_t error = B_OK;
570 	fFile.Unset();
571 	// read the first four bytes, and check, if they identify a resource file
572 	char magic[4];
573 	read_exactly(file, 0, magic, 4, "Failed to read magic number.");
574 	if (!memcmp(magic, kX86ResourceFileMagic, 4)) {
575 		// x86 resource file
576 		fHostEndianess = B_HOST_IS_LENDIAN;
577 		fFileType = FILE_TYPE_X86_RESOURCE;
578 		fFile.SetTo(file, kX86ResourcesOffset);
579 	} else if (!memcmp(magic, kPEFFileMagic1, 4)) {
580 		PEFContainerHeader pefHeader;
581 		read_exactly(file, 0, &pefHeader, kPEFContainerHeaderSize,
582 					 "Failed to read PEF container header.");
583 		if (!memcmp(pefHeader.tag2, kPPCResourceFileMagic, 4)) {
584 			// PPC resource file
585 			fHostEndianess = B_HOST_IS_BENDIAN;
586 			fFileType = FILE_TYPE_PPC_RESOURCE;
587 			fFile.SetTo(file, kPPCResourcesOffset);
588 		} else if (!memcmp(pefHeader.tag2, kPEFFileMagic2, 4)) {
589 			// PEF file
590 			fFileType = FILE_TYPE_PEF;
591 			_InitPEFFile(file, pefHeader);
592 		} else
593 			throw Exception("File is not a resource file.");
594 	} else if (!memcmp(magic, kELFFileMagic, 4)) {
595 		// ELF file
596 		fFileType = FILE_TYPE_ELF;
597 		_InitELFFile(file);
598 	} else if (!memcmp(magic, kX86ResourceFileMagic, 2)) {
599 		// x86 resource file with screwed magic?
600 		Warnings::AddCurrentWarning("File magic is 0x%08lx. Should be 0x%08lx "
601 									"for x86 resource file. Try anyway.",
602 									ntohl(*(uint32*)magic),
603 									ntohl(*(uint32*)kX86ResourceFileMagic));
604 		fHostEndianess = B_HOST_IS_LENDIAN;
605 		fFileType = FILE_TYPE_X86_RESOURCE;
606 		fFile.SetTo(file, kX86ResourcesOffset);
607 	} else
608 		throw Exception("File is not a resource file.");
609 	error = fFile.InitCheck();
610 	if (error != B_OK)
611 		throw Exception(error, "Failed to initialize resource file.");
612 	// get the file size
613 	fFileSize = 0;
614 	error = fFile.GetSize(&fFileSize);
615 	if (error != B_OK)
616 		throw Exception(error, "Failed to get the file size.");
617 }
618 
619 // _InitELFFile
620 void
621 ResourceFile::_InitELFFile(BFile& file)
622 {
623 	status_t error = B_OK;
624 	// get the file size
625 	off_t fileSize = 0;
626 	error = file.GetSize(&fileSize);
627 	if (error != B_OK)
628 		throw Exception(error, "Failed to get the file size.");
629 	// read ELF header
630 	Elf32_Ehdr fileHeader;
631 	read_exactly(file, 0, &fileHeader, sizeof(Elf32_Ehdr),
632 				 "Failed to read ELF header.");
633 	// check data encoding (endianess)
634 	switch (fileHeader.e_ident[EI_DATA]) {
635 		case ELFDATA2LSB:
636 			fHostEndianess = B_HOST_IS_LENDIAN;
637 			break;
638 		case ELFDATA2MSB:
639 			fHostEndianess = B_HOST_IS_BENDIAN;
640 			break;
641 		default:
642 		case ELFDATANONE:
643 			throw Exception("Unsupported ELF data encoding.");
644 			break;
645 	}
646 	// get the header values
647 	uint32 headerSize				= _GetUInt16(fileHeader.e_ehsize);
648 	uint32 programHeaderTableOffset	= _GetUInt32(fileHeader.e_phoff);
649 	uint32 programHeaderSize		= _GetUInt16(fileHeader.e_phentsize);
650 	uint32 programHeaderCount		= _GetUInt16(fileHeader.e_phnum);
651 	uint32 sectionHeaderTableOffset	= _GetUInt32(fileHeader.e_shoff);
652 	uint32 sectionHeaderSize		= _GetUInt16(fileHeader.e_shentsize);
653 	uint32 sectionHeaderCount		= _GetUInt16(fileHeader.e_shnum);
654 	bool hasProgramHeaderTable = (programHeaderTableOffset != 0);
655 	bool hasSectionHeaderTable = (sectionHeaderTableOffset != 0);
656 //printf("headerSize              : %lu\n", headerSize);
657 //printf("programHeaderTableOffset: %lu\n", programHeaderTableOffset);
658 //printf("programHeaderSize       : %lu\n", programHeaderSize);
659 //printf("programHeaderCount      : %lu\n", programHeaderCount);
660 //printf("sectionHeaderTableOffset: %lu\n", sectionHeaderTableOffset);
661 //printf("sectionHeaderSize       : %lu\n", sectionHeaderSize);
662 //printf("sectionHeaderCount      : %lu\n", sectionHeaderCount);
663 	// check the sanity of the header values
664 	// ELF header size
665 	if (headerSize < sizeof(Elf32_Ehdr) || headerSize > kMaxELFHeaderSize) {
666 		throw Exception("Invalid ELF header: invalid ELF header size: %lu.",
667 						headerSize);
668 	}
669 	uint32 resourceOffset = headerSize;
670 	uint32 resourceAlignment = 0;
671 	// program header table offset and entry count/size
672 	uint32 programHeaderTableSize = 0;
673 	if (hasProgramHeaderTable) {
674 		if (programHeaderTableOffset < headerSize
675 			|| programHeaderTableOffset > fileSize) {
676 			throw Exception("Invalid ELF header: invalid program header table "
677 							"offset: %lu.", programHeaderTableOffset);
678 		}
679 		programHeaderTableSize = programHeaderSize * programHeaderCount;
680 		if (programHeaderSize < sizeof(Elf32_Phdr)
681 			|| programHeaderTableOffset + programHeaderTableSize > fileSize) {
682 			throw Exception("Invalid ELF header: program header table exceeds "
683 							"file: %lu.",
684 							programHeaderTableOffset + programHeaderTableSize);
685 		}
686 		resourceOffset = max(resourceOffset, programHeaderTableOffset
687 											 + programHeaderTableSize);
688 		// iterate through the program headers
689 		for (int32 i = 0; i < (int32)programHeaderCount; i++) {
690 			uint32 shOffset = programHeaderTableOffset + i * programHeaderSize;
691 			Elf32_Phdr programHeader;
692 			read_exactly(file, shOffset, &programHeader, sizeof(Elf32_Shdr),
693 						 "Failed to read ELF program header.");
694 			// get the header values
695 			uint32 type			= _GetUInt32(programHeader.p_type);
696 			uint32 offset		= _GetUInt32(programHeader.p_offset);
697 			uint32 size			= _GetUInt32(programHeader.p_filesz);
698 			uint32 alignment	= _GetUInt32(programHeader.p_align);
699 //printf("segment: type: %ld, offset: %lu, size: %lu, alignment: %lu\n",
700 //type, offset, size, alignment);
701 			// check the values
702 			// PT_NULL marks the header unused,
703 			if (type != PT_NULL) {
704 				if (/*offset < headerSize ||*/ offset > fileSize) {
705 					throw Exception("Invalid ELF program header: invalid "
706 									"program offset: %lu.", offset);
707 				}
708 				uint32 segmentEnd = offset + size;
709 				if (segmentEnd > fileSize) {
710 					throw Exception("Invalid ELF section header: segment "
711 									"exceeds file: %lu.", segmentEnd);
712 				}
713 				resourceOffset = max(resourceOffset, segmentEnd);
714 				resourceAlignment = max(resourceAlignment, alignment);
715 			}
716 		}
717 	}
718 	// section header table offset and entry count/size
719 	uint32 sectionHeaderTableSize = 0;
720 	if (hasSectionHeaderTable) {
721 		if (sectionHeaderTableOffset < headerSize
722 			|| sectionHeaderTableOffset > fileSize) {
723 			throw Exception("Invalid ELF header: invalid section header table "
724 							"offset: %lu.", sectionHeaderTableOffset);
725 		}
726 		sectionHeaderTableSize = sectionHeaderSize * sectionHeaderCount;
727 		if (sectionHeaderSize < sizeof(Elf32_Shdr)
728 			|| sectionHeaderTableOffset + sectionHeaderTableSize > fileSize) {
729 			throw Exception("Invalid ELF header: section header table exceeds "
730 							"file: %lu.",
731 							sectionHeaderTableOffset + sectionHeaderTableSize);
732 		}
733 		resourceOffset = max(resourceOffset, sectionHeaderTableOffset
734 											 + sectionHeaderTableSize);
735 		// iterate through the section headers
736 		for (int32 i = 0; i < (int32)sectionHeaderCount; i++) {
737 			uint32 shOffset = sectionHeaderTableOffset + i * sectionHeaderSize;
738 			Elf32_Shdr sectionHeader;
739 			read_exactly(file, shOffset, &sectionHeader, sizeof(Elf32_Shdr),
740 						 "Failed to read ELF section header.");
741 			// get the header values
742 			uint32 type		= _GetUInt32(sectionHeader.sh_type);
743 			uint32 offset	= _GetUInt32(sectionHeader.sh_offset);
744 			uint32 size		= _GetUInt32(sectionHeader.sh_size);
745 //printf("section: type: %ld, offset: %lu, size: %lu\n", type, offset, size);
746 			// check the values
747 			// SHT_NULL marks the header unused,
748 			// SHT_NOBITS sections take no space in the file
749 			if (type != SHT_NULL && type != SHT_NOBITS) {
750 				if (offset < headerSize || offset > fileSize) {
751 					throw Exception("Invalid ELF section header: invalid "
752 									"section offset: %lu.", offset);
753 				}
754 				uint32 sectionEnd = offset + size;
755 				if (sectionEnd > fileSize) {
756 					throw Exception("Invalid ELF section header: section "
757 									"exceeds file: %lu.", sectionEnd);
758 				}
759 				resourceOffset = max(resourceOffset, sectionEnd);
760 			}
761 		}
762 	}
763 //printf("resourceOffset: %lu\n", resourceOffset);
764 	// align the offset
765 	if (resourceAlignment < kELFMinResourceAlignment)
766 		resourceAlignment = kELFMinResourceAlignment;
767 	if (resourceAlignment > kELFMaxResourceAlignment) {
768 		throw Exception("The ELF object file requires an invalid alignment: "
769 						"%lu.", resourceAlignment);
770 	}
771 	resourceOffset = align_value(resourceOffset, resourceAlignment);
772 //printf("resourceOffset: %lu\n", resourceOffset);
773 	if (resourceOffset >= fileSize)
774 		throw Exception("The ELF object file does not contain resources.");
775 	// fine, init the offset file
776 	fFile.SetTo(file, resourceOffset);
777 }
778 
779 // _InitPEFFile
780 void
781 ResourceFile::_InitPEFFile(BFile& file, const PEFContainerHeader& pefHeader)
782 {
783 	status_t error = B_OK;
784 	// get the file size
785 	off_t fileSize = 0;
786 	error = file.GetSize(&fileSize);
787 	if (error != B_OK)
788 		throw Exception(error, "Failed to get the file size.");
789 	// check architecture -- we support PPC only
790 	if (memcmp(pefHeader.architecture, kPEFArchitecturePPC, 4))
791 		throw Exception("PEF file architecture is not PPC.");
792 	fHostEndianess = B_HOST_IS_BENDIAN;
793 	// get the section count
794 	uint16 sectionCount = _GetUInt16(pefHeader.sectionCount);
795 	// iterate through the PEF sections headers
796 	uint32 sectionHeaderTableOffset = kPEFContainerHeaderSize;
797 	uint32 sectionHeaderTableEnd
798 		= sectionHeaderTableOffset + sectionCount * kPEFSectionHeaderSize;
799 	uint32 resourceOffset = sectionHeaderTableEnd;
800 	for (int32 i = 0; i < (int32)sectionCount; i++) {
801 		uint32 shOffset = sectionHeaderTableOffset + i * kPEFSectionHeaderSize;
802 		PEFSectionHeader sectionHeader;
803 		read_exactly(file, shOffset, &sectionHeader, kPEFSectionHeaderSize,
804 					 "Failed to read PEF section header.");
805 		// get the header values
806 		uint32 offset	= _GetUInt32(sectionHeader.containerOffset);
807 		uint32 size		= _GetUInt32(sectionHeader.packedSize);
808 		// check the values
809 		if (offset < sectionHeaderTableEnd || offset > fileSize) {
810 			throw Exception("Invalid PEF section header: invalid "
811 							"section offset: %lu.", offset);
812 		}
813 		uint32 sectionEnd = offset + size;
814 		if (sectionEnd > fileSize) {
815 			throw Exception("Invalid PEF section header: section "
816 							"exceeds file: %lu.", sectionEnd);
817 		}
818 		resourceOffset = max(resourceOffset, sectionEnd);
819 	}
820 	// init the offset file
821 	fFile.SetTo(file, resourceOffset);
822 }
823 
824 // _ReadHeader
825 void
826 ResourceFile::_ReadHeader()
827 {
828 	// read the header
829 	resources_header header;
830 	read_exactly(fFile, 0, &header, kResourcesHeaderSize,
831 				 "Failed to read the header.");
832 	// check the header
833 	// magic
834 	uint32 magic = _GetUInt32(header.rh_resources_magic);
835 	if (magic == kResourcesHeaderMagic) {
836 		// everything is fine
837 	} else if (B_SWAP_INT32(magic) == kResourcesHeaderMagic) {
838 		const char* endianessStr[2] = { "little", "big" };
839 		int32 endianess
840 			= (fHostEndianess == ((bool)B_HOST_IS_LENDIAN ? 0 : 1));
841 		Warnings::AddCurrentWarning("Endianess seems to be %s, although %s "
842 									"was expected.",
843 									endianessStr[1 - endianess],
844 									endianessStr[endianess]);
845 		fHostEndianess = !fHostEndianess;
846 	} else
847 		throw Exception("Invalid resources header magic.");
848 	// resource count
849 	uint32 resourceCount = _GetUInt32(header.rh_resource_count);
850 	if (resourceCount > kMaxResourceCount)
851 		throw Exception("Bad number of resources.");
852 	// index section offset
853 	uint32 indexSectionOffset = _GetUInt32(header.rh_index_section_offset);
854 	if (indexSectionOffset != kResourceIndexSectionOffset) {
855 		throw Exception("Unexpected resource index section offset. Is: %lu, "
856 						"should be: %lu.", indexSectionOffset,
857 						kResourceIndexSectionOffset);
858 	}
859 	// admin section size
860 	uint32 indexSectionSize = kResourceIndexSectionHeaderSize
861 							  + kResourceIndexEntrySize * resourceCount;
862 	indexSectionSize = align_value(indexSectionSize,
863 								   kResourceIndexSectionAlignment);
864 	uint32 adminSectionSize = _GetUInt32(header.rh_admin_section_size);
865 	if (adminSectionSize != indexSectionOffset + indexSectionSize) {
866 		throw Exception("Unexpected resource admin section size. Is: %lu, "
867 						"should be: %lu.", adminSectionSize,
868 						indexSectionOffset + indexSectionSize);
869 	}
870 	// set the resource count
871 	fResourceCount = resourceCount;
872 }
873 
874 // _ReadIndex
875 void
876 ResourceFile::_ReadIndex()
877 {
878 	// read the header
879 	resource_index_section_header header;
880 	read_exactly(fFile, kResourceIndexSectionOffset, &header,
881 				 kResourceIndexSectionHeaderSize,
882 				 "Failed to read the resource index section header.");
883 	// check the header
884 	// index section offset
885 	uint32 indexSectionOffset = _GetUInt32(header.rish_index_section_offset);
886 	if (indexSectionOffset != kResourceIndexSectionOffset) {
887 		throw Exception("Unexpected resource index section offset. Is: %lu, "
888 						"should be: %lu.", indexSectionOffset,
889 						kResourceIndexSectionOffset);
890 	}
891 	// index section size
892 	uint32 expectedIndexSectionSize = kResourceIndexSectionHeaderSize
893 		+ kResourceIndexEntrySize * fResourceCount;
894 	expectedIndexSectionSize = align_value(expectedIndexSectionSize,
895 										   kResourceIndexSectionAlignment);
896 	uint32 indexSectionSize = _GetUInt32(header.rish_index_section_size);
897 	if (indexSectionSize != expectedIndexSectionSize) {
898 		throw Exception("Unexpected resource index section size. Is: %lu, "
899 						"should be: %lu.", indexSectionSize,
900 						expectedIndexSectionSize);
901 	}
902 	// unknown section offset
903 	uint32 unknownSectionOffset
904 		= _GetUInt32(header.rish_unknown_section_offset);
905 	if (unknownSectionOffset != indexSectionOffset + indexSectionSize) {
906 		throw Exception("Unexpected resource index section size. Is: %lu, "
907 						"should be: %lu.", unknownSectionOffset,
908 						indexSectionOffset + indexSectionSize);
909 	}
910 	// unknown section size
911 	uint32 unknownSectionSize = _GetUInt32(header.rish_unknown_section_size);
912 	if (unknownSectionSize != kUnknownResourceSectionSize) {
913 		throw Exception("Unexpected resource index section offset. Is: %lu, "
914 						"should be: %lu.", unknownSectionOffset,
915 						kUnknownResourceSectionSize);
916 	}
917 	// info table offset and size
918 	uint32 infoTableOffset = _GetUInt32(header.rish_info_table_offset);
919 	uint32 infoTableSize = _GetUInt32(header.rish_info_table_size);
920 	if (infoTableOffset + infoTableSize > fFileSize)
921 		throw Exception("Invalid info table location.");
922 	fInfoTableItem = new ResourceItem;
923 	fInfoTableItem->SetLocation(infoTableOffset, infoTableSize);
924 	// read the index entries
925 	uint32 indexTableOffset = indexSectionOffset
926 							  + kResourceIndexSectionHeaderSize;
927 	int32 maxResourceCount = (unknownSectionOffset - indexTableOffset)
928 							 / kResourceIndexEntrySize;
929 	int32 actualResourceCount = 0;
930 	bool tableEndReached = false;
931 	for (int32 i = 0; !tableEndReached && i < maxResourceCount; i++) {
932 		// read one entry
933 		tableEndReached = !_ReadIndexEntry(i, indexTableOffset,
934 										   (i >= fResourceCount));
935 		if (!tableEndReached)
936 			actualResourceCount++;
937 	}
938 	// check resource count
939 	if (actualResourceCount != fResourceCount) {
940 		if (actualResourceCount > fResourceCount) {
941 			Warnings::AddCurrentWarning("Resource index table contains "
942 										"%ld entries, although it should be "
943 										"%ld only.", actualResourceCount,
944 										fResourceCount);
945 		}
946 		fResourceCount = actualResourceCount;
947 	}
948 }
949 
950 // _ReadIndexEntry
951 bool
952 ResourceFile::_ReadIndexEntry(int32 index, uint32 tableOffset, bool peekAhead)
953 {
954 	bool result = true;
955 	resource_index_entry entry;
956 	// read one entry
957 	off_t entryOffset = tableOffset + index * kResourceIndexEntrySize;
958 	read_exactly(fFile, entryOffset, &entry, kResourceIndexEntrySize,
959 				 "Failed to read a resource index entry.");
960 	// check, if the end is reached early
961 	if (result && check_pattern(entryOffset, &entry,
962 								kResourceIndexEntrySize / 4, fHostEndianess)) {
963 		if (!peekAhead) {
964 			Warnings::AddCurrentWarning("Unexpected end of resource index "
965 										"table at index: %ld (/%ld).",
966 										index + 1, fResourceCount);
967 		}
968 		result = false;
969 	}
970 	uint32 offset = _GetUInt32(entry.rie_offset);
971 	uint32 size = _GetUInt32(entry.rie_size);
972 	// check the location
973 	if (result && offset + size > fFileSize) {
974 		if (peekAhead) {
975 			Warnings::AddCurrentWarning("Invalid data after resource index "
976 										"table.");
977 		} else {
978 			throw Exception("Invalid resource index entry: index: %ld, "
979 							"offset: %lu (%lx), size: %lu (%lx).", index + 1,
980 							offset, offset, size, size);
981 		}
982 		result = false;
983 	}
984 	// add the entry
985 	if (result) {
986 		ResourceItem* item = new ResourceItem;
987 		item->SetLocation(offset, size);
988 		AddItem(item, index);
989 	}
990 	return result;
991 }
992 
993 // _ReadInfoTable
994 void
995 ResourceFile::_ReadInfoTable()
996 {
997 	status_t error = B_OK;
998 	error = fInfoTableItem->LoadData(fFile);
999 	if (error != B_OK)
1000 		throw Exception(error, "Failed to read resource info table.");
1001 	const void* tableData = fInfoTableItem->GetData();
1002 	int32 dataSize = fInfoTableItem->GetSize();
1003 	//
1004 	bool* readIndices = new bool[fResourceCount + 1];	// + 1 => always > 0
1005 	for (int32 i = 0; i < fResourceCount; i++)
1006 		readIndices[i] = false;
1007 	AutoDeleter<bool> deleter(readIndices, true);
1008 	MemArea area(tableData, dataSize);
1009 	const void* data = tableData;
1010 	// check the table end/check sum
1011 	if (_ReadInfoTableEnd(data, dataSize))
1012 		dataSize -= kResourceInfoTableEndSize;
1013 	// read the infos
1014 	int32 resourceIndex = 1;
1015 	uint32 minRemainderSize
1016 		= kMinResourceInfoBlockSize + kResourceInfoSeparatorSize;
1017 	while (area.check(data, minRemainderSize)) {
1018 		// read a resource block
1019 		if (!area.check(data, kMinResourceInfoBlockSize)) {
1020 			throw Exception("Unexpected end of resource info table at index "
1021 							"%ld.", resourceIndex);
1022 		}
1023 		const resource_info_block* infoBlock
1024 			= (const resource_info_block*)data;
1025 		type_code type = _GetUInt32(infoBlock->rib_type);
1026 		// read the infos of this block
1027 		const resource_info* info = infoBlock->rib_info;
1028 		while (info) {
1029 			data = _ReadResourceInfo(area, info, type, readIndices);
1030 			// prepare for next iteration, if there is another info
1031 			if (!area.check(data, kResourceInfoSeparatorSize)) {
1032 				throw Exception("Unexpected end of resource info table after "
1033 								"index %ld.", resourceIndex);
1034 			}
1035 			const resource_info_separator* separator
1036 				= (const resource_info_separator*)data;
1037 			if (_GetUInt32(separator->ris_value1) == 0xffffffff
1038 				&& _GetUInt32(separator->ris_value2) == 0xffffffff) {
1039 				// info block ends
1040 				info = NULL;
1041 				data = skip_bytes(data, kResourceInfoSeparatorSize);
1042 			} else {
1043 				// another info follows
1044 				info = (const resource_info*)data;
1045 			}
1046 			resourceIndex++;
1047 		}
1048 		// end of the info block
1049 	}
1050 	// handle special case: empty resource info table
1051 	if (resourceIndex == 1) {
1052 		if (!area.check(data, kResourceInfoSeparatorSize)) {
1053 			throw Exception("Unexpected end of resource info table.");
1054 		}
1055 		const resource_info_separator* tableTerminator
1056 			= (const resource_info_separator*)data;
1057 		if (_GetUInt32(tableTerminator->ris_value1) != 0xffffffff
1058 			|| _GetUInt32(tableTerminator->ris_value2) != 0xffffffff) {
1059 			throw Exception("The resource info table ought to be empty, but "
1060 							"is not properly terminated.");
1061 		}
1062 		data = skip_bytes(data, kResourceInfoSeparatorSize);
1063 	}
1064 	// Check, if the correct number of bytes are remaining.
1065 	uint32 bytesLeft = (const char*)tableData + dataSize - (const char*)data;
1066 	if (bytesLeft != 0) {
1067 		throw Exception("Error at the end of the resource info table: %lu "
1068 						"bytes are remaining.", bytesLeft);
1069 	}
1070 	// check, if all items have been initialized
1071 	for (int32 i = fResourceCount - 1; i >= 0; i--) {
1072 		if (!readIndices[i]) {
1073 			Warnings::AddCurrentWarning("Resource item at index %ld "
1074 										"has no info. Item removed.", i + 1);
1075 			if (ResourceItem* item = RemoveItem(i))
1076 				delete item;
1077 			fResourceCount--;
1078 		}
1079 	}
1080 }
1081 
1082 // _ReadInfoTableEnd
1083 bool
1084 ResourceFile::_ReadInfoTableEnd(const void* data, int32 dataSize)
1085 {
1086 	bool hasTableEnd = true;
1087 	if ((uint32)dataSize < kResourceInfoSeparatorSize)
1088 		throw Exception("Info table is too short.");
1089 	if ((uint32)dataSize < kResourceInfoTableEndSize)
1090 		hasTableEnd = false;
1091 	if (hasTableEnd) {
1092 		const resource_info_table_end* tableEnd
1093 			= (const resource_info_table_end*)
1094 			  skip_bytes(data, dataSize - kResourceInfoTableEndSize);
1095 		if (_GetInt32(tableEnd->rite_terminator) != 0)
1096 			hasTableEnd = false;
1097 		if (hasTableEnd) {
1098 			dataSize -= kResourceInfoTableEndSize;
1099 			// checksum
1100 			uint32 checkSum = calculate_checksum(data, dataSize);
1101 			uint32 fileCheckSum = _GetUInt32(tableEnd->rite_check_sum);
1102 			if (checkSum != fileCheckSum) {
1103 				throw Exception("Invalid resource info table check sum: In "
1104 								"file: %lx, calculated: %lx.", fileCheckSum,
1105 								checkSum);
1106 			}
1107 		}
1108 	}
1109 	if (!hasTableEnd)
1110 		Warnings::AddCurrentWarning("resource info table has no check sum.");
1111 	return hasTableEnd;
1112 }
1113 
1114 // _ReadResourceInfo
1115 const void*
1116 ResourceFile::_ReadResourceInfo(const MemArea& area, const resource_info* info,
1117 								type_code type, bool* readIndices)
1118 {
1119 	int32 id = _GetInt32(info->ri_id);
1120 	int32 index = _GetInt32(info->ri_index);
1121 	uint16 nameSize = _GetUInt16(info->ri_name_size);
1122 	const char* name = info->ri_name;
1123 	// check the values
1124 	bool ignore = false;
1125 	// index
1126 	if (index < 1 || index > fResourceCount) {
1127 		Warnings::AddCurrentWarning("Invalid index field in resource "
1128 									"info table: %lu.", index);
1129 		ignore = true;
1130 	}
1131 	if (!ignore) {
1132 		if (readIndices[index - 1]) {
1133 			throw Exception("Multiple resource infos with the same index "
1134 							"field: %ld.", index);
1135 		}
1136 		readIndices[index - 1] = true;
1137 	}
1138 	// name size
1139 	if (!area.check(name, nameSize)) {
1140 		throw Exception("Invalid name size (%d) for index %ld in "
1141 						"resource info table.", (int)nameSize, index);
1142 	}
1143 	// check, if name is null terminated
1144 	if (name[nameSize - 1] != 0) {
1145 		Warnings::AddCurrentWarning("Name for index %ld in "
1146 									"resource info table is not null "
1147 									"terminated.", index);
1148 	}
1149 	// set the values
1150 	if (!ignore) {
1151 		BString resourceName(name, nameSize);
1152 		if (ResourceItem* item = ItemAt(index - 1))
1153 			item->SetIdentity(type, id, resourceName.String());
1154 		else {
1155 			throw Exception("Unexpected error: No resource item at index "
1156 							"%ld.", index);
1157 		}
1158 	}
1159 	return skip_bytes(name, nameSize);
1160 }
1161