1 /*
2 Copyright (C) 2001-present by Serge Lamikhov-Center
3
4 Permission is hereby granted, free of charge, to any person obtaining a copy
5 of this software and associated documentation files (the "Software"), to deal
6 in the Software without restriction, including without limitation the rights
7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 copies of the Software, and to permit persons to whom the Software is
9 furnished to do so, subject to the following conditions:
10
11 The above copyright notice and this permission notice shall be included in
12 all copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 THE SOFTWARE.
21 */
22
23 #ifdef _MSC_VER
24 #define _SCL_SECURE_NO_WARNINGS
25 #define ELFIO_NO_INTTYPES
26 #endif
27
28 #include <boost/test/unit_test.hpp>
29 #include <boost/test/tools/output_test_stream.hpp>
30 using boost::test_tools::output_test_stream;
31
32 #include <elfio/elfio.hpp>
33
34 using namespace ELFIO;
35
36 ////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(modinfo_read)37 BOOST_AUTO_TEST_CASE( modinfo_read )
38 {
39 elfio reader;
40 BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/zavl.ko" ), true );
41
42 section* modinfo_sec = reader.sections[".modinfo"];
43 BOOST_REQUIRE_NE( modinfo_sec, nullptr );
44
45 const_modinfo_section_accessor modinfo( modinfo_sec );
46 BOOST_REQUIRE_EQUAL( modinfo.get_attribute_num(), (Elf_Word)9 );
47
48 struct
49 {
50 std::string field;
51 std::string value;
52 } attributes[] = { { "version", "0.8.3-1ubuntu12.1" },
53 { "license", "CDDL" },
54 { "author", "OpenZFS on Linux" },
55 { "description", "Generic AVL tree implementation" },
56 { "srcversion", "98E85778E754CF75DEF9E8E" },
57 { "depends", "spl" },
58 { "retpoline", "Y" },
59 { "name", "zavl" },
60 { "vermagic", "5.4.0-42-generic SMP mod_unload " } };
61
62 for ( auto i = 0; i < sizeof( attributes ) / sizeof( attributes[0] );
63 i++ ) {
64 std::string field;
65 std::string value;
66 modinfo.get_attribute( i, field, value );
67
68 BOOST_CHECK_EQUAL( field, attributes[i].field );
69 BOOST_CHECK_EQUAL( value, attributes[i].value );
70 }
71
72 for ( auto i = 0; i < sizeof( attributes ) / sizeof( attributes[0] );
73 i++ ) {
74 std::string field = attributes[i].field;
75 std::string value;
76 modinfo.get_attribute( field, value );
77
78 BOOST_CHECK_EQUAL( value, attributes[i].value );
79 }
80 }
81
82 ////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(modinfo_write)83 BOOST_AUTO_TEST_CASE( modinfo_write )
84 {
85 elfio writer;
86 BOOST_REQUIRE_EQUAL( writer.load( "elf_examples/zavl.ko" ), true );
87
88 section* modinfo_sec = writer.sections[".modinfo"];
89 BOOST_REQUIRE_NE( modinfo_sec, nullptr );
90
91 modinfo_section_accessor modinfo( modinfo_sec );
92 BOOST_REQUIRE_EQUAL( modinfo.get_attribute_num(), (Elf_Word)9 );
93
94 modinfo.add_attribute( "test1", "value1" );
95 modinfo.add_attribute( "test2", "value2" );
96
97 BOOST_REQUIRE_EQUAL( modinfo.get_attribute_num(), (Elf_Word)11 );
98
99 BOOST_REQUIRE_EQUAL( writer.save( "elf_examples/zavl_gen.ko" ), true );
100
101 elfio reader;
102 BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/zavl_gen.ko" ), true );
103
104 modinfo_sec = reader.sections[".modinfo"];
105 BOOST_REQUIRE_NE( modinfo_sec, nullptr );
106
107 const_modinfo_section_accessor modinfo1( modinfo_sec );
108 BOOST_REQUIRE_EQUAL( modinfo1.get_attribute_num(), (Elf_Word)11 );
109
110 struct
111 {
112 std::string field;
113 std::string value;
114 } attributes[] = { { "version", "0.8.3-1ubuntu12.1" },
115 { "license", "CDDL" },
116 { "author", "OpenZFS on Linux" },
117 { "description", "Generic AVL tree implementation" },
118 { "srcversion", "98E85778E754CF75DEF9E8E" },
119 { "depends", "spl" },
120 { "retpoline", "Y" },
121 { "name", "zavl" },
122 { "vermagic", "5.4.0-42-generic SMP mod_unload " },
123 { "test1", "value1" },
124 { "test2", "value2" } };
125
126 for ( auto i = 0; i < sizeof( attributes ) / sizeof( attributes[0] );
127 i++ ) {
128 std::string field;
129 std::string value;
130 modinfo.get_attribute( i, field, value );
131
132 BOOST_CHECK_EQUAL( field, attributes[i].field );
133 BOOST_CHECK_EQUAL( value, attributes[i].value );
134 }
135
136 for ( auto i = 0; i < sizeof( attributes ) / sizeof( attributes[0] );
137 i++ ) {
138 std::string field = attributes[i].field;
139 std::string value;
140 modinfo.get_attribute( field, value );
141
142 BOOST_CHECK_EQUAL( value, attributes[i].value );
143 }
144 }
145
146 ////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(array_read_32)147 BOOST_AUTO_TEST_CASE( array_read_32 )
148 {
149 elfio reader;
150 BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/hello_32" ), true );
151
152 section* array_sec = reader.sections[".ctors"];
153 BOOST_REQUIRE_NE( array_sec, nullptr );
154
155 const_array_section_accessor array( reader, array_sec );
156 BOOST_REQUIRE_EQUAL( array.get_entries_num(), (Elf_Xword)2 );
157 Elf64_Addr addr;
158 BOOST_CHECK_EQUAL( array.get_entry( 0, addr ), true );
159 BOOST_CHECK_EQUAL( addr, 0xFFFFFFFF );
160 BOOST_CHECK_EQUAL( array.get_entry( 1, addr ), true );
161 BOOST_CHECK_EQUAL( addr, 0x00000000 );
162 }
163
164 ////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(array_read_64)165 BOOST_AUTO_TEST_CASE( array_read_64 )
166 {
167 elfio reader;
168 BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/hello_64" ), true );
169
170 section* array_sec = reader.sections[".ctors"];
171 BOOST_REQUIRE_NE( array_sec, nullptr );
172
173 const_array_section_accessor array( reader, array_sec );
174 BOOST_REQUIRE_EQUAL( array.get_entries_num(), (Elf_Xword)2 );
175 Elf64_Addr addr;
176 BOOST_CHECK_EQUAL( array.get_entry( 0, addr ), true );
177 BOOST_CHECK_EQUAL( addr, 0xFFFFFFFFFFFFFFFF );
178 BOOST_CHECK_EQUAL( array.get_entry( 1, addr ), true );
179 BOOST_CHECK_EQUAL( addr, 0x0000000000000000 );
180 }
181
182 ////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(init_array_read_64)183 BOOST_AUTO_TEST_CASE( init_array_read_64 )
184 {
185 elfio reader;
186 Elf64_Addr addr;
187 BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/ctors" ), true );
188
189 section* array_sec = reader.sections[".init_array"];
190 BOOST_REQUIRE_NE( array_sec, nullptr );
191
192 const_array_section_accessor array( reader, array_sec );
193 BOOST_REQUIRE_EQUAL( array.get_entries_num(), (Elf_Xword)2 );
194 BOOST_CHECK_EQUAL( array.get_entry( 0, addr ), true );
195 BOOST_CHECK_EQUAL( addr, 0x12C0 );
196 BOOST_CHECK_EQUAL( array.get_entry( 1, addr ), true );
197 BOOST_CHECK_EQUAL( addr, 0x149F );
198
199 array_sec = reader.sections[".fini_array"];
200 BOOST_REQUIRE_NE( array_sec, nullptr );
201
202 array_section_accessor arrayf( reader, array_sec );
203 BOOST_REQUIRE_EQUAL( arrayf.get_entries_num(), (Elf_Xword)1 );
204 BOOST_CHECK_EQUAL( arrayf.get_entry( 0, addr ), true );
205 BOOST_CHECK_EQUAL( addr, 0x1280 );
206 }
207
208 ////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(init_array_write_64)209 BOOST_AUTO_TEST_CASE( init_array_write_64 )
210 {
211 elfio reader;
212 Elf64_Addr addr;
213 BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/ctors" ), true );
214
215 section* array_sec = reader.sections[".init_array"];
216 BOOST_REQUIRE_NE( array_sec, nullptr );
217
218 array_section_accessor array( reader, array_sec );
219 BOOST_REQUIRE_EQUAL( array.get_entries_num(), (Elf_Xword)2 );
220 BOOST_CHECK_EQUAL( array.get_entry( 0, addr ), true );
221 BOOST_CHECK_EQUAL( addr, 0x12C0 );
222 BOOST_CHECK_EQUAL( array.get_entry( 1, addr ), true );
223 BOOST_CHECK_EQUAL( addr, 0x149F );
224
225 array.add_entry( 0x12345678 );
226
227 BOOST_REQUIRE_EQUAL( array.get_entries_num(), (Elf_Xword)3 );
228 BOOST_CHECK_EQUAL( array.get_entry( 0, addr ), true );
229 BOOST_CHECK_EQUAL( addr, 0x12C0 );
230 BOOST_CHECK_EQUAL( array.get_entry( 1, addr ), true );
231 BOOST_CHECK_EQUAL( addr, 0x149F );
232 BOOST_CHECK_EQUAL( array.get_entry( 2, addr ), true );
233 BOOST_CHECK_EQUAL( addr, 0x12345678 );
234 }
235
236 ////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(test_hex)237 BOOST_AUTO_TEST_CASE( test_hex )
238 {
239 BOOST_CHECK_EQUAL( to_hex_string( 1 ), "0x1" );
240 BOOST_CHECK_EQUAL( to_hex_string( 10 ), "0xA" );
241 BOOST_CHECK_EQUAL( to_hex_string( 0x12345678 ), "0x12345678" );
242 BOOST_CHECK_EQUAL( to_hex_string( 0xFFFFFFFF ), "0xFFFFFFFF" );
243 BOOST_CHECK_EQUAL( to_hex_string( 0xFFFFFFFFFFFFFFFF ),
244 "0xFFFFFFFFFFFFFFFF" );
245 }
246