Commit | Line | Data |
---|---|---|
645f8123 ILT |
1 | // elfcpp_file.h -- file access for elfcpp -*- C++ -*- |
2 | ||
3 | // This header file defines the class Elf_file which can be used to | |
4 | // read useful data from an ELF file. The functions here are all | |
5 | // templates which take a file interface object as a parameter. This | |
6 | // type must have a subtype View. This type must support two methods: | |
7 | // View view(off_t file_offset, off_t data_size) | |
8 | // returns a View for the specified part of the file. | |
9 | // void error(const char* printf_format, ...) | |
10 | // prints an error message and does not return. The subtype View must | |
11 | // support a method | |
12 | // const unsigned char* data() | |
13 | // which returns a pointer to a buffer containing the requested data. | |
14 | // This general interface is used to read data from the file. Objects | |
15 | // of type View will never survive longer than the elfcpp function. | |
16 | ||
17 | // Some of these functions must return a reference to part of the | |
18 | // file. To use these, the file interface must support a subtype | |
19 | // Location: | |
20 | // Location(off_t file_offset, off_t data_size) | |
21 | // To use this in conjunction with the accessors types Shdr, etc., the | |
22 | // file interface should support an overload of view: | |
23 | // View view(Location) | |
24 | // This permits writing | |
25 | // elfcpp::Shdr shdr(file, ef.section_header(n)); | |
26 | ||
27 | #ifndef ELFPCP_FILE_H | |
28 | #define ELFCPP_FILE_H | |
29 | ||
30 | #include <string> | |
31 | #include <cstring> | |
32 | ||
33 | namespace elfcpp | |
34 | { | |
35 | ||
36 | // This object is used to read an ELF file. | |
37 | // SIZE: The size of file, 32 or 64. | |
38 | // BIG_ENDIAN: Whether the file is in big-endian format. | |
39 | // FILE: A file reading type as described above. | |
40 | ||
41 | template<int size, bool big_endian, typename File> | |
42 | class Elf_file | |
43 | { | |
44 | private: | |
45 | typedef Elf_file<size, big_endian, File> This; | |
46 | ||
47 | public: | |
48 | static const int ehdr_size = Elf_sizes<size>::ehdr_size; | |
49 | static const int phdr_size = Elf_sizes<size>::phdr_size; | |
50 | static const int shdr_size = Elf_sizes<size>::shdr_size; | |
51 | static const int sym_size = Elf_sizes<size>::sym_size; | |
52 | static const int rel_size = Elf_sizes<size>::rel_size; | |
53 | static const int rela_size = Elf_sizes<size>::rela_size; | |
54 | ||
55 | typedef Ehdr<size, big_endian> Ef_ehdr; | |
56 | typedef Phdr<size, big_endian> Ef_phdr; | |
57 | typedef Shdr<size, big_endian> Ef_shdr; | |
58 | typedef Sym<size, big_endian> Ef_sym; | |
59 | ||
60 | // Construct an Elf_file given an ELF file header. | |
61 | Elf_file(File* file, const Ef_ehdr& ehdr) | |
62 | { this->construct(file, ehdr); } | |
63 | ||
64 | // Construct an ELF file. | |
65 | inline | |
66 | Elf_file(File* file); | |
67 | ||
68 | // Return the file offset to the section headers. | |
69 | off_t | |
70 | shoff() const | |
71 | { return this->shoff_; } | |
72 | ||
73 | // Return the number of sections. | |
74 | unsigned int | |
75 | shnum() | |
76 | { | |
77 | this->initialize_shnum(); | |
78 | return this->shnum_; | |
79 | } | |
80 | ||
81 | // Return the section index of the section name string table. | |
82 | unsigned int | |
83 | shstrndx() | |
84 | { | |
85 | this->initialize_shnum(); | |
86 | return this->shstrndx_; | |
87 | } | |
88 | ||
89 | // Return the location of the header of section SHNDX. | |
90 | typename File::Location | |
91 | section_header(unsigned int shndx) | |
92 | { | |
93 | return typename File::Location(this->section_header_offset(shndx), | |
94 | shdr_size); | |
95 | } | |
96 | ||
97 | // Return the name of section SHNDX. | |
98 | std::string | |
99 | section_name(unsigned int shndx); | |
100 | ||
101 | // Return the location of the contents of section SHNDX. | |
102 | typename File::Location | |
103 | section_contents(unsigned int shndx); | |
104 | ||
105 | private: | |
106 | // Shared constructor code. | |
107 | void | |
108 | construct(File* file, const Ef_ehdr& ehdr); | |
109 | ||
110 | // Initialize shnum_ and shstrndx_. | |
111 | void | |
112 | initialize_shnum(); | |
113 | ||
114 | // Return the file offset of the header of section SHNDX. | |
115 | off_t | |
116 | section_header_offset(unsigned int shndx); | |
117 | ||
118 | // The file we are reading. | |
119 | File* file_; | |
120 | // The file offset to the section headers. | |
121 | off_t shoff_; | |
122 | // The number of sections. | |
123 | unsigned int shnum_; | |
124 | // The section index of the section name string table. | |
125 | unsigned int shstrndx_; | |
126 | }; | |
127 | ||
128 | // Template function definitions. | |
129 | ||
130 | // Construct an Elf_file given an ELF file header. | |
131 | ||
132 | template<int size, bool big_endian, typename File> | |
133 | void | |
134 | Elf_file<size, big_endian, File>::construct(File* file, const Ef_ehdr& ehdr) | |
135 | { | |
136 | this->file_ = file; | |
137 | this->shoff_ = ehdr.get_e_shoff(); | |
138 | this->shnum_ = ehdr.get_e_shnum(); | |
139 | this->shstrndx_ = ehdr.get_e_shstrndx(); | |
140 | if (ehdr.get_e_ehsize() != This::ehdr_size) | |
141 | file->error(_("bad e_ehsize (%d != %d)"), | |
142 | ehdr.get_e_ehsize(), This::ehdr_size); | |
143 | if (ehdr.get_e_shentsize() != This::shdr_size) | |
144 | file->error(_("bad e_shentsize (%d != %d)"), | |
145 | ehdr.get_e_shentsize(), This::shdr_size); | |
146 | } | |
147 | ||
148 | // Construct an ELF file. | |
149 | ||
150 | template<int size, bool big_endian, typename File> | |
151 | inline | |
152 | Elf_file<size, big_endian, File>::Elf_file(File* file) | |
153 | { | |
154 | typename File::View v(file->view(file_header_offset, This::ehdr_size)); | |
155 | this->construct(file, Ef_ehdr(v.data())); | |
156 | } | |
157 | ||
158 | // Initialize the shnum_ and shstrndx_ fields, handling overflow. | |
159 | ||
160 | template<int size, bool big_endian, typename File> | |
161 | void | |
162 | Elf_file<size, big_endian, File>::initialize_shnum() | |
163 | { | |
164 | if ((this->shnum_ == 0 || this->shstrndx_ == SHN_XINDEX) | |
165 | && this->shoff_ != 0) | |
166 | { | |
167 | typename File::View v(this->file_->view(this->shoff_, This::shdr_size)); | |
168 | Ef_shdr shdr(v.data()); | |
169 | if (this->shnum_ == 0) | |
170 | this->shnum_ = shdr.get_sh_size(); | |
171 | if (this->shstrndx_ == SHN_XINDEX) | |
172 | this->shstrndx_ = shdr.get_sh_link(); | |
173 | } | |
174 | } | |
175 | ||
176 | // Return the file offset of the section header of section SHNDX. | |
177 | ||
178 | template<int size, bool big_endian, typename File> | |
179 | off_t | |
180 | Elf_file<size, big_endian, File>::section_header_offset(unsigned int shndx) | |
181 | { | |
182 | if (shndx >= this->shnum()) | |
183 | this->file_->error(_("section_header_offset: bad shndx %u >= %u"), | |
184 | shndx, this->shnum()); | |
185 | return this->shoff_ + This::shdr_size * shndx; | |
186 | } | |
187 | ||
188 | // Return the name of section SHNDX. | |
189 | ||
190 | template<int size, bool big_endian, typename File> | |
191 | std::string | |
192 | Elf_file<size, big_endian, File>::section_name(unsigned int shndx) | |
193 | { | |
194 | File* const file = this->file_; | |
195 | ||
196 | // Get the section name offset. | |
197 | unsigned int sh_name; | |
198 | { | |
199 | typename File::View v(file->view(this->section_header_offset(shndx), | |
200 | This::shdr_size)); | |
201 | Ef_shdr shdr(v.data()); | |
202 | sh_name = shdr.get_sh_name(); | |
203 | } | |
204 | ||
205 | // Get the file offset for the section name string table data. | |
206 | off_t shstr_off; | |
207 | off_t shstr_size; | |
208 | { | |
209 | const unsigned int shstrndx = this->shstrndx_; | |
210 | typename File::View v(file->view(this->section_header_offset(shstrndx), | |
211 | This::shdr_size)); | |
212 | Ef_shdr shstr_shdr(v.data()); | |
213 | shstr_off = shstr_shdr.get_sh_offset(); | |
214 | shstr_size = shstr_shdr.get_sh_size(); | |
215 | } | |
216 | ||
217 | if (sh_name >= shstr_size) | |
218 | file->error(_("bad section name offset for section %u: %u"), | |
219 | shndx, sh_name); | |
220 | ||
221 | typename File::View v(file->view(shstr_off, shstr_size)); | |
222 | ||
223 | const unsigned char* datau = v.data(); | |
224 | const char* data = reinterpret_cast<const char*>(datau); | |
225 | const void* p = ::memchr(data + sh_name, '\0', shstr_size - sh_name); | |
226 | if (p == NULL) | |
227 | file->error(_("missing null terminator for name of section %u"), | |
228 | shndx); | |
229 | ||
230 | size_t len = static_cast<const char*>(p) - (data + sh_name); | |
231 | ||
232 | return std::string(data + sh_name, len); | |
233 | } | |
234 | ||
235 | // Return the contents of section SHNDX. | |
236 | ||
237 | template<int size, bool big_endian, typename File> | |
238 | typename File::Location | |
239 | Elf_file<size, big_endian, File>::section_contents(unsigned int shndx) | |
240 | { | |
241 | File* const file = this->file_; | |
242 | ||
243 | if (shndx >= this->shnum()) | |
244 | file->error(_("section_contents: bad shndx %u >= %u"), | |
245 | shndx, this->shnum()); | |
246 | ||
247 | typename File::View v(file->view(this->section_header_offset(shndx), | |
248 | This::shdr_size)); | |
249 | Ef_shdr shdr(v.data()); | |
250 | return typename File::Location(shdr.get_sh_offset(), shdr.get_sh_size()); | |
251 | } | |
252 | ||
253 | } // End namespace elfcpp. | |
254 | ||
255 | #endif // !defined(ELFCPP_FILE_H) |