xref: /haiku/src/tools/elfsymbolpatcher/ElfFile.cpp (revision e81a954787e50e56a7f06f72705b7859b6ab06d1) 
1 // ElfFile.cpp
2 //------------------------------------------------------------------------------
3 //	Copyright (c) 2003, Ingo Weinhold
4 //
5 //	Permission is hereby granted, free of charge, to any person obtaining a
6 //	copy of this software and associated documentation files (the "Software"),
7 //	to deal in the Software without restriction, including without limitation
8 //	the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 //	and/or sell copies of the Software, and to permit persons to whom the
10 //	Software is furnished to do so, subject to the following conditions:
11 //
12 //	The above copyright notice and this permission notice shall be included in
13 //	all copies or substantial portions of the Software.
14 //
15 //	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 //	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 //	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 //	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 //	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 //	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 //	DEALINGS IN THE SOFTWARE.
22 //
23 //	File Name:		ElfFile.cpp
24 //	Author:			Ingo Weinhold (bonefish@users.sf.net)
25 //	Description:	Implementation of classes for accessing ELF file,
26 //					or more precisely for iterating through their relocation
27 //					sections.
28 //------------------------------------------------------------------------------
29 
30 #include <new>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 
35 #include "ElfFile.h"
36 
37 // sanity bounds
38 static const uint32	kMaxELFHeaderSize			= sizeof(Elf32_Ehdr) + 32;
39 
40 // read_exactly
41 static
42 status_t
43 read_exactly(BPositionIO &file, off_t position, void *buffer, size_t size,
44 			 const char *errorMessage = NULL)
45 {
46 	status_t error = B_OK;
47 	ssize_t read = file.ReadAt(position, buffer, size);
48 	if (read < 0)
49 		error = read;
50 	else if ((size_t)read != size)
51 		error = B_ERROR;
52 	if (error != B_OK && errorMessage)
53 		puts(errorMessage);
54 	return error;
55 }
56 
57 
58 // ElfSection
59 
60 class SymbolPatcher::ElfSection {
61 public:
62 								ElfSection();
63 								~ElfSection();
64 
65 			void				SetTo(ElfFile* file, Elf32_Shdr* header);
66 			void				Unset();
67 			bool				IsInitialized() const	{ return fHeader; }
68 
69 			ElfFile*			GetFile() const;
70 			Elf32_Shdr*			GetHeader() const		{ return fHeader; }
71 			const char*			GetName() const;
72 			uint8*				GetData() const			{ return fData; }
73 			size_t				GetSize() const;
74 			Elf32_Word			GetType() const;
75 			Elf32_Word			GetLink() const;
76 			Elf32_Word			GetInfo() const;
77 			size_t				GetEntrySize() const;
78 			int32				CountEntries() const;
79 
80 			status_t			Load();
81 			void				Unload();
82 
83 			void				Dump();
84 
85 private:
86 			ElfFile*			fFile;
87 			Elf32_Shdr*			fHeader;
88 			uint8*				fData;
89 };
90 
91 // constructor
92 ElfSection::ElfSection()
93 	: fFile(NULL),
94 	  fHeader(NULL),
95 	  fData(NULL)
96 {
97 }
98 
99 // destructor
100 ElfSection::~ElfSection()
101 {
102 	Unset();
103 }
104 
105 // SetTo
106 void
107 ElfSection::SetTo(ElfFile* file, Elf32_Shdr* header)
108 {
109 	Unset();
110 	fFile = file;
111 	fHeader = header;
112 }
113 
114 // Unset
115 void
116 ElfSection::Unset()
117 {
118 	Unload();
119 	fFile = NULL;
120 	fHeader = NULL;
121 }
122 
123 // GetFile
124 ElfFile*
125 ElfSection::GetFile() const
126 {
127 	return fFile;
128 }
129 
130 // GetName
131 const char*
132 ElfSection::GetName() const
133 {
134 	const char* name = NULL;
135 	if (fHeader && fFile) {
136 		size_t size = 0;
137 		const char* nameSection = fFile->GetSectionHeaderStrings(&size);
138 		if (nameSection && fHeader->sh_name < size)
139 			name = nameSection + fHeader->sh_name;
140 	}
141 	return name;
142 }
143 
144 // GetSize
145 size_t
146 ElfSection::GetSize() const
147 {
148 	return fHeader->sh_size;
149 }
150 
151 // GetType
152 Elf32_Word
153 ElfSection::GetType() const
154 {
155 	return fHeader->sh_type;
156 }
157 
158 // GetLink
159 Elf32_Word
160 ElfSection::GetLink() const
161 {
162 	return fHeader->sh_link;
163 }
164 
165 // GetInfo
166 Elf32_Word
167 ElfSection::GetInfo() const
168 {
169 	return fHeader->sh_info;
170 }
171 
172 // GetEntrySize
173 size_t
174 ElfSection::GetEntrySize() const
175 {
176 	return fHeader->sh_entsize;
177 }
178 
179 // CountEntries
180 int32
181 ElfSection::CountEntries() const
182 {
183 	int32 count = 0;
184 	if (fHeader) {
185 		if (GetEntrySize() == 0)
186 			return 0;
187 		count = GetSize() / GetEntrySize();
188 	}
189 	return count;
190 }
191 
192 // Load
193 status_t
194 ElfSection::Load()
195 {
196 	status_t error = B_ERROR;
197 	if (fHeader && !fData && fHeader->sh_type != SHT_NULL
198 		 && fHeader->sh_type != SHT_NOBITS) {
199 		BFile* file = fFile->GetFile();
200 		// allocate memory
201 		fData = new uint8[fHeader->sh_size];
202 		if (!fData)
203 			return B_NO_MEMORY;
204 		// read the data
205 		error = read_exactly(*file, fHeader->sh_offset, fData,
206 							 fHeader->sh_size, "Failed to read section!\n");
207 		if (error != B_OK)
208 			Unload();
209 	}
210 	return error;
211 }
212 
213 // Unload
214 void
215 ElfSection::Unload()
216 {
217 	if (fData) {
218 		delete[] fData;
219 		fData = NULL;
220 	}
221 }
222 
223 // Dump
224 void
225 ElfSection::Dump()
226 {
227 	printf("section %32s: size: %lu\n", GetName(), GetSize());
228 }
229 
230 
231 // ElfSymbol
232 
233 // constructor
234 ElfSymbol::ElfSymbol(ElfSection* section, int32 index)
235 	: fSection(section),
236 	  fIndex(index),
237 	  fSymbol(NULL)
238 {
239 }
240 
241 // destructor
242 ElfSymbol::~ElfSymbol()
243 {
244 	Unset();
245 }
246 
247 // SetTo
248 void
249 ElfSymbol::SetTo(ElfSection* section, int32 index)
250 {
251 	Unset();
252 	fSection = section;
253 	fIndex = index;
254 }
255 
256 // Unset
257 void
258 ElfSymbol::Unset()
259 {
260 	fSection = NULL;
261 	fIndex = -1;
262 	fSymbol = NULL;
263 }
264 
265 // GetSymbolStruct
266 const Elf32_Sym*
267 ElfSymbol::GetSymbolStruct()
268 {
269 	Elf32_Sym* symbol = fSymbol;
270 	if (!symbol && fSection && fSection->GetData()) {
271 		size_t symbolSize = fSection->GetEntrySize();
272 		if (symbolSize == 0)
273 			return NULL;
274 		int32 symbolCount = fSection->GetSize() / symbolSize;
275 		if (fIndex >= 0 && fIndex < symbolCount)
276 			symbol = (Elf32_Sym*)(fSection->GetData() + fIndex * symbolSize);
277 	}
278 	return symbol;
279 }
280 
281 // GetName
282 const char*
283 ElfSymbol::GetName()
284 {
285 	const char* name = NULL;
286 	if (const Elf32_Sym* symbol = GetSymbolStruct()) {
287 		size_t size = 0;
288 		const char* data = fSection->GetFile()->GetStringSectionStrings(
289 			fSection->GetLink(), &size);
290 		if (data && symbol->st_name < size)
291 			name = data + symbol->st_name;
292 	}
293 	return name;
294 }
295 
296 // GetBinding
297 uint32
298 ElfSymbol::GetBinding()
299 {
300 	uint32 binding = STB_LOCAL;
301 	if (const Elf32_Sym* symbol = GetSymbolStruct())
302 		binding = ELF32_ST_BIND(symbol->st_info);
303 	return binding;
304 }
305 
306 // GetType
307 uint32
308 ElfSymbol::GetType()
309 {
310 	uint32 type = STT_NOTYPE;
311 	if (const Elf32_Sym* symbol = GetSymbolStruct())
312 		type = ELF32_ST_TYPE(symbol->st_info);
313 	return type;
314 }
315 
316 // GetTargetSectionIndex
317 uint32
318 ElfSymbol::GetTargetSectionIndex()
319 {
320 	uint32 index = SHN_UNDEF;
321 	if (const Elf32_Sym* symbol = GetSymbolStruct())
322 		index = symbol->st_shndx;
323 	return index;
324 }
325 
326 
327 // ElfRelocation
328 
329 // constructor
330 ElfRelocation::ElfRelocation(ElfSection* section, int32 index)
331 	: fSection(section),
332 	  fIndex(index),
333 	  fRelocation(NULL)
334 {
335 }
336 
337 // destructor
338 ElfRelocation::~ElfRelocation()
339 {
340 	Unset();
341 }
342 
343 // SetTo
344 void
345 ElfRelocation::SetTo(ElfSection* section, int32 index)
346 {
347 	Unset();
348 	fSection = section;
349 	fIndex = index;
350 }
351 
352 // Unset
353 void
354 ElfRelocation::Unset()
355 {
356 	fSection = NULL;
357 	fIndex = -1;
358 	fRelocation = NULL;
359 }
360 
361 // GetRelocationStruct
362 Elf32_Rel*
363 ElfRelocation::GetRelocationStruct()
364 {
365 	Elf32_Rel* relocation = fRelocation;
366 	if (!relocation && fSection) {
367 		if (!fSection->GetData()) {
368 			if (fSection->Load() != B_OK)
369 				return NULL;
370 		}
371 		size_t entrySize = fSection->GetEntrySize();
372 		if (entrySize == 0 || entrySize < sizeof(Elf32_Rel))
373 			return NULL;
374 		int32 entryCount = fSection->GetSize() / entrySize;
375 		if (fIndex >= 0 && fIndex < entryCount) {
376 			relocation = (Elf32_Rel*)(fSection->GetData()
377 						 + fIndex * entrySize);
378 		}
379 	}
380 	return relocation;
381 }
382 
383 // GetType
384 uint32
385 ElfRelocation::GetType()
386 {
387 	uint32 type = R_386_NONE;
388 	if (Elf32_Rel* relocation = GetRelocationStruct())
389 		type = ELF32_R_TYPE(relocation->r_info);
390 	return type;
391 }
392 
393 // GetSymbolIndex
394 uint32
395 ElfRelocation::GetSymbolIndex()
396 {
397 	uint32 index = 0;
398 	if (Elf32_Rel* relocation = GetRelocationStruct())
399 		index = ELF32_R_SYM(relocation->r_info);
400 	return index;
401 }
402 
403 // GetOffset
404 Elf32_Addr
405 ElfRelocation::GetOffset()
406 {
407 	Elf32_Addr offset = 0;
408 	if (Elf32_Rel* relocation = GetRelocationStruct())
409 		offset = relocation->r_offset;
410 	return offset;
411 }
412 
413 // GetSymbol
414 status_t
415 ElfRelocation::GetSymbol(ElfSymbol* symbol)
416 {
417 	status_t error = B_BAD_VALUE;
418 	if (symbol && fSection) {
419 		uint32 index = GetSymbolIndex();
420 		if (ElfSection* symbols
421 			= fSection->GetFile()->SectionAt(fSection->GetLink(), true)) {
422 			symbol->SetTo(symbols, index);
423 			if (symbol->GetSymbolStruct())
424 				error = B_OK;
425 		}
426 	}
427 	return error;
428 }
429 
430 
431 // ElfRelocationIterator
432 
433 // constructor
434 ElfRelocationIterator::ElfRelocationIterator(ElfFile* file)
435 	: fFile(file),
436 	  fSectionIndex(-1),
437 	  fEntryIndex(-1)
438 {
439 }
440 
441 // destructor
442 ElfRelocationIterator::~ElfRelocationIterator()
443 {
444 }
445 
446 // GetNext
447 bool
448 ElfRelocationIterator::GetNext(ElfRelocation* relocation)
449 {
450 	bool result = false;
451 	if (fFile && relocation) {
452 		// set to possible entry
453 		ElfSection* section = NULL;
454 		if (fSectionIndex < 0) {
455 			fSectionIndex = 0;
456 			fEntryIndex = 0;
457 			section = _FindNextSection();
458 		} else {
459 			fEntryIndex++;
460 			section = fFile->SectionAt(fSectionIndex);
461 		}
462 		// find next valid entry
463 		while (section && fEntryIndex >= section->CountEntries()) {
464 			fSectionIndex++;
465 			section = _FindNextSection();
466 			fEntryIndex = 0;
467 		}
468 		// set result
469 		if (section) {
470 			relocation->SetTo(section, fEntryIndex);
471 			result = true;
472 		}
473 	}
474 	return result;
475 }
476 
477 // _FindNextSection
478 ElfSection*
479 ElfRelocationIterator::_FindNextSection()
480 {
481 	if (fFile) {
482 		for (; fSectionIndex < fFile->CountSections(); fSectionIndex++) {
483 			ElfSection* section = fFile->SectionAt(fSectionIndex);
484 			if (section && section->GetType() == SHT_REL)
485 				return section;
486 		}
487 	}
488 	return NULL;
489 }
490 
491 
492 // ElfFile
493 
494 // constructor
495 ElfFile::ElfFile()
496 	: fFile(),
497 	  fSectionHeaders(NULL),
498 	  fSections(NULL),
499 	  fSectionCount(0),
500 	  fSectionHeaderSize(0)
501 {
502 }
503 
504 // destructor
505 ElfFile::~ElfFile()
506 {
507 	Unset();
508 }
509 
510 // SetTo
511 status_t
512 ElfFile::SetTo(const char *filename)
513 {
514 	Unset();
515 	status_t error = _SetTo(filename);
516 	if (error)
517 		Unset();
518 	return error;
519 }
520 
521 // Unset
522 void
523 ElfFile::Unset()
524 {
525 	// delete sections
526 	if (fSections) {
527 		delete[] fSections;
528 		fSections = NULL;
529 	}
530 	// delete section headers
531 	if (fSectionHeaders) {
532 		delete[] fSectionHeaders;
533 		fSectionHeaders = NULL;
534 	}
535 	fSectionCount = 0;
536 	fSectionHeaderSize = 0;
537 	fFile.Unset();
538 }
539 
540 // Unload
541 void
542 ElfFile::Unload()
543 {
544 	for (int i = 0; i < fSectionCount; i++)
545 		fSections[i].Unload();
546 }
547 
548 // GetSectionHeaderStrings
549 const char*
550 ElfFile::GetSectionHeaderStrings(size_t* size)
551 {
552 	return GetStringSectionStrings(fHeader.e_shstrndx, size);
553 }
554 
555 // GetStringSectionStrings
556 const char*
557 ElfFile::GetStringSectionStrings(int32 index, size_t* _size)
558 {
559 	const char* data = NULL;
560 	size_t size = 0;
561 	if (ElfSection* section = SectionAt(index, true)) {
562 		data = (const char*)section->GetData();
563 		size = (data ? section->GetSize() : 0);
564 	}
565 	// set results
566 	if (_size)
567 		*_size = size;
568 	return data;
569 }
570 
571 // SectionAt
572 ElfSection*
573 ElfFile::SectionAt(int32 index, bool load)
574 {
575 	ElfSection* section = NULL;
576 	if (fSections && index >= 0 && index < fSectionCount) {
577 		section = fSections + index;
578 		if (load && !section->GetData()) {
579 			if (section->Load() != B_OK) {
580 				section = NULL;
581 				printf("Failed to load section %ld\n", index);
582 			}
583 		}
584 	}
585 	return section;
586 }
587 
588 // Dump
589 void
590 ElfFile::Dump()
591 {
592 	printf("%ld sections\n", fSectionCount);
593 	for (int i = 0; i < fSectionCount; i++)
594 		fSections[i].Dump();
595 }
596 
597 // _SetTo
598 status_t
599 ElfFile::_SetTo(const char *filename)
600 {
601 	if (!filename)
602 		return B_BAD_VALUE;
603 	// open file
604 	status_t error = fFile.SetTo(filename, B_READ_ONLY);
605 	// get the file size
606 	off_t fileSize = 0;
607 	error = fFile.GetSize(&fileSize);
608 	if (error != B_OK) {
609 		printf("Failed to get file size!\n");
610 		return error;
611 	}
612 	// read ELF header
613 	error = read_exactly(fFile, 0, &fHeader, sizeof(Elf32_Ehdr),
614 						 "Failed to read ELF object header!\n");
615 	if (error != B_OK)
616 		return error;
617 	// check the ident field
618 	// magic
619 	if (fHeader.e_ident[EI_MAG0] != ELFMAG0
620 		|| fHeader.e_ident[EI_MAG1] != ELFMAG1
621 		|| fHeader.e_ident[EI_MAG2] != ELFMAG2
622 		|| fHeader.e_ident[EI_MAG3] != ELFMAG3) {
623 		printf("Bad ELF file magic!\n");
624 		return B_BAD_VALUE;
625 	}
626 	// class
627 	if (fHeader.e_ident[EI_CLASS] != ELFCLASS32) {
628 		printf("Wrong ELF class!\n");
629 		return B_BAD_VALUE;
630 	}
631 	// check data encoding (endianess)
632 	if (fHeader.e_ident[EI_DATA] != ELFDATA2LSB) {
633 		printf("Wrong data encoding!\n");
634 		return B_BAD_VALUE;
635 	}
636 	// version
637 	if (fHeader.e_ident[EI_VERSION] != EV_CURRENT) {
638 		printf("Wrong data encoding!\n");
639 		return B_BAD_VALUE;
640 	}
641 	// get the header values
642 	uint32 headerSize				= fHeader.e_ehsize;
643 	uint32 sectionHeaderTableOffset	= fHeader.e_shoff;
644 	uint32 sectionHeaderSize		= fHeader.e_shentsize;
645 	uint32 sectionHeaderCount		= fHeader.e_shnum;
646 	// check the sanity of the header values
647 	// ELF header size
648 	if (headerSize < sizeof(Elf32_Ehdr) || headerSize > kMaxELFHeaderSize) {
649 		printf("Invalid ELF header: invalid ELF header size: %lu.",
650 			   headerSize);
651 		return B_BAD_VALUE;
652 	}
653 	// section header table offset
654 	if (sectionHeaderTableOffset == 0) {
655 		printf("ELF file has no section header table!\n");
656 		return B_BAD_VALUE;
657 	}
658 	uint32 sectionHeaderTableSize = 0;
659 	if (sectionHeaderTableOffset < headerSize
660 		|| sectionHeaderTableOffset > fileSize) {
661 		printf("Invalid ELF header: invalid section header table offset: %lu.",
662 			   sectionHeaderTableOffset);
663 		return B_BAD_VALUE;
664 	}
665 	// section header table offset
666 	sectionHeaderTableSize = sectionHeaderSize * sectionHeaderCount;
667 	if (sectionHeaderSize < sizeof(Elf32_Shdr)
668 		|| sectionHeaderTableOffset + sectionHeaderTableSize > fileSize) {
669 		printf("Invalid ELF header: section header table exceeds file: %lu.",
670 			   sectionHeaderTableOffset + sectionHeaderTableSize);
671 		return B_BAD_VALUE;
672 	}
673 	// allocate memory for the section header table and read it
674 	fSectionHeaders = new(std::nothrow) uint8[sectionHeaderTableSize];
675 	fSectionCount = sectionHeaderCount;
676 	fSectionHeaderSize = sectionHeaderSize;
677 	if (!fSectionHeaders)
678 		return B_NO_MEMORY;
679 	error = read_exactly(fFile, sectionHeaderTableOffset, fSectionHeaders,
680 						 sectionHeaderTableSize,
681 						 "Failed to read section headers!\n");
682 	if (error != B_OK)
683 		return error;
684 	// allocate memory for the section pointers
685 	fSections = new(std::nothrow) ElfSection[fSectionCount];
686 	if (!fSections)
687 		return B_NO_MEMORY;
688 	// init the sections
689 	for (int i = 0; i < fSectionCount; i++)
690 		fSections[i].SetTo(this, _SectionHeaderAt(i));
691 	return error;
692 }
693 
694 // _SectionHeaderAt
695 Elf32_Shdr*
696 ElfFile::_SectionHeaderAt(int32 index)
697 {
698 	Elf32_Shdr* header = NULL;
699 	if (fSectionHeaders && index >= 0 && index < fSectionCount)
700 		header = (Elf32_Shdr*)(fSectionHeaders + index * fSectionHeaderSize);
701 	return header;
702 }
703 
704 // _LoadSection
705 status_t
706 ElfFile::_LoadSection(int32 index)
707 {
708 	status_t error = B_OK;
709 	if (fSections && index >= 0 && index < fSectionCount) {
710 		ElfSection& section = fSections[index];
711 		error = section.Load();
712 	} else
713 		error = B_BAD_VALUE;
714 	return error;
715 }
716 
717