1 /*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <gtest/gtest.h>
18
19 #include <dlfcn.h>
20 #include <libgen.h>
21 #include <limits.h>
22 #include <stdio.h>
23 #include <stdint.h>
24
25 #include <string>
26
27 #define ASSERT_SUBSTR(needle, haystack) \
28 ASSERT_PRED_FORMAT2(::testing::IsSubstring, needle, haystack)
29
30 static bool g_called = false;
DlSymTestFunction()31 extern "C" void DlSymTestFunction() {
32 g_called = true;
33 }
34
35 static int g_ctor_function_called = 0;
36
37 extern "C" void ctor_function() __attribute__ ((constructor));
38
ctor_function()39 extern "C" void ctor_function() {
40 g_ctor_function_called = 17;
41 }
42
TEST(dlfcn,ctor_function_call)43 TEST(dlfcn, ctor_function_call) {
44 ASSERT_EQ(17, g_ctor_function_called);
45 }
46
TEST(dlfcn,dlsym_in_self)47 TEST(dlfcn, dlsym_in_self) {
48 dlerror(); // Clear any pending errors.
49 void* self = dlopen(NULL, RTLD_NOW);
50 ASSERT_TRUE(self != NULL);
51 ASSERT_TRUE(dlerror() == NULL);
52
53 void* sym = dlsym(self, "DlSymTestFunction");
54 ASSERT_TRUE(sym != NULL);
55
56 void (*function)() = reinterpret_cast<void(*)()>(sym);
57
58 g_called = false;
59 function();
60 ASSERT_TRUE(g_called);
61
62 ASSERT_EQ(0, dlclose(self));
63 }
64
TEST(dlfcn,dlsym_with_dependencies)65 TEST(dlfcn, dlsym_with_dependencies) {
66 void* handle = dlopen("libtest_with_dependency.so", RTLD_NOW);
67 ASSERT_TRUE(handle != NULL);
68 dlerror();
69 // This symbol is in DT_NEEDED library.
70 void* sym = dlsym(handle, "getRandomNumber");
71 ASSERT_TRUE(sym != NULL);
72 int (*fn)(void);
73 fn = reinterpret_cast<int (*)(void)>(sym);
74 EXPECT_EQ(4, fn());
75 dlclose(handle);
76 }
77
TEST(dlfcn,dlopen_noload)78 TEST(dlfcn, dlopen_noload) {
79 void* handle = dlopen("libtest_simple.so", RTLD_NOW | RTLD_NOLOAD);
80 ASSERT_TRUE(handle == NULL);
81 handle = dlopen("libtest_simple.so", RTLD_NOW);
82 void* handle2 = dlopen("libtest_simple.so", RTLD_NOW | RTLD_NOLOAD);
83 ASSERT_TRUE(handle != NULL);
84 ASSERT_TRUE(handle2 != NULL);
85 ASSERT_TRUE(handle == handle2);
86 ASSERT_EQ(0, dlclose(handle));
87 ASSERT_EQ(0, dlclose(handle2));
88 }
89
TEST(dlfcn,dlopen_failure)90 TEST(dlfcn, dlopen_failure) {
91 void* self = dlopen("/does/not/exist", RTLD_NOW);
92 ASSERT_TRUE(self == NULL);
93 #if defined(__BIONIC__)
94 ASSERT_STREQ("dlopen failed: library \"/does/not/exist\" not found", dlerror());
95 #else
96 ASSERT_STREQ("/does/not/exist: cannot open shared object file: No such file or directory", dlerror());
97 #endif
98 }
99
ConcurrentDlErrorFn(void *)100 static void* ConcurrentDlErrorFn(void*) {
101 dlopen("/child/thread", RTLD_NOW);
102 return reinterpret_cast<void*>(strdup(dlerror()));
103 }
104
TEST(dlfcn,dlerror_concurrent)105 TEST(dlfcn, dlerror_concurrent) {
106 dlopen("/main/thread", RTLD_NOW);
107 const char* main_thread_error = dlerror();
108 ASSERT_SUBSTR("/main/thread", main_thread_error);
109
110 pthread_t t;
111 ASSERT_EQ(0, pthread_create(&t, NULL, ConcurrentDlErrorFn, NULL));
112 void* result;
113 ASSERT_EQ(0, pthread_join(t, &result));
114 char* child_thread_error = static_cast<char*>(result);
115 ASSERT_SUBSTR("/child/thread", child_thread_error);
116 free(child_thread_error);
117
118 ASSERT_SUBSTR("/main/thread", main_thread_error);
119 }
120
TEST(dlfcn,dlsym_failures)121 TEST(dlfcn, dlsym_failures) {
122 dlerror(); // Clear any pending errors.
123 void* self = dlopen(NULL, RTLD_NOW);
124 ASSERT_TRUE(self != NULL);
125 ASSERT_TRUE(dlerror() == NULL);
126
127 void* sym;
128
129 #if defined(__BIONIC__) && !defined(__LP64__)
130 // RTLD_DEFAULT in lp32 bionic is not (void*)0
131 // so it can be distinguished from the NULL handle.
132 sym = dlsym(NULL, "test");
133 ASSERT_TRUE(sym == NULL);
134 ASSERT_SUBSTR("dlsym library handle is null", dlerror());
135 #endif
136
137 // NULL symbol name.
138 #if defined(__BIONIC__)
139 // glibc marks this parameter non-null and SEGVs if you cheat.
140 sym = dlsym(self, NULL);
141 ASSERT_TRUE(sym == NULL);
142 ASSERT_SUBSTR("", dlerror());
143 #endif
144
145 // Symbol that doesn't exist.
146 sym = dlsym(self, "ThisSymbolDoesNotExist");
147 ASSERT_TRUE(sym == NULL);
148 ASSERT_SUBSTR("undefined symbol: ThisSymbolDoesNotExist", dlerror());
149
150 ASSERT_EQ(0, dlclose(self));
151 }
152
TEST(dlfcn,dladdr)153 TEST(dlfcn, dladdr) {
154 dlerror(); // Clear any pending errors.
155 void* self = dlopen(NULL, RTLD_NOW);
156 ASSERT_TRUE(self != NULL);
157 ASSERT_TRUE(dlerror() == NULL);
158
159 void* sym = dlsym(self, "DlSymTestFunction");
160 ASSERT_TRUE(sym != NULL);
161
162 // Deliberately ask dladdr for an address inside a symbol, rather than the symbol base address.
163 void* addr = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(sym) + 2);
164
165 Dl_info info;
166 int rc = dladdr(addr, &info);
167 ASSERT_NE(rc, 0); // Zero on error, non-zero on success.
168
169 // Get the name of this executable.
170 char executable_path[PATH_MAX];
171 rc = readlink("/proc/self/exe", executable_path, sizeof(executable_path));
172 ASSERT_NE(rc, -1);
173 executable_path[rc] = '\0';
174 std::string executable_name(basename(executable_path));
175
176 // The filename should be that of this executable.
177 // Note that we don't know whether or not we have the full path, so we want an "ends_with" test.
178 std::string dli_fname(info.dli_fname);
179 dli_fname = basename(&dli_fname[0]);
180 ASSERT_EQ(dli_fname, executable_name);
181
182 // The symbol name should be the symbol we looked up.
183 ASSERT_STREQ(info.dli_sname, "DlSymTestFunction");
184
185 // The address should be the exact address of the symbol.
186 ASSERT_EQ(info.dli_saddr, sym);
187
188 // Look in /proc/pid/maps to find out what address we were loaded at.
189 // TODO: factor /proc/pid/maps parsing out into a class and reuse all over bionic.
190 void* base_address = NULL;
191 char line[BUFSIZ];
192 FILE* fp = fopen("/proc/self/maps", "r");
193 ASSERT_TRUE(fp != NULL);
194 while (fgets(line, sizeof(line), fp) != NULL) {
195 uintptr_t start = strtoul(line, 0, 16);
196 line[strlen(line) - 1] = '\0'; // Chomp the '\n'.
197 char* path = strchr(line, '/');
198 if (path != NULL && strcmp(executable_path, path) == 0) {
199 base_address = reinterpret_cast<void*>(start);
200 break;
201 }
202 }
203 fclose(fp);
204
205 // The base address should be the address we were loaded at.
206 ASSERT_EQ(info.dli_fbase, base_address);
207
208 ASSERT_EQ(0, dlclose(self));
209 }
210
TEST(dlfcn,dladdr_invalid)211 TEST(dlfcn, dladdr_invalid) {
212 Dl_info info;
213
214 dlerror(); // Clear any pending errors.
215
216 // No symbol corresponding to NULL.
217 ASSERT_EQ(dladdr(NULL, &info), 0); // Zero on error, non-zero on success.
218 ASSERT_TRUE(dlerror() == NULL); // dladdr(3) doesn't set dlerror(3).
219
220 // No symbol corresponding to a stack address.
221 ASSERT_EQ(dladdr(&info, &info), 0); // Zero on error, non-zero on success.
222 ASSERT_TRUE(dlerror() == NULL); // dladdr(3) doesn't set dlerror(3).
223 }
224
225 // Our dynamic linker doesn't support GNU hash tables.
226 #if defined(__BIONIC__)
227 // GNU-style ELF hash tables are incompatible with the MIPS ABI.
228 // MIPS requires .dynsym to be sorted to match the GOT but GNU-style requires sorting by hash code.
229 #if !defined(__mips__)
TEST(dlfcn,dlopen_library_with_only_gnu_hash)230 TEST(dlfcn, dlopen_library_with_only_gnu_hash) {
231 dlerror(); // Clear any pending errors.
232 void* handle = dlopen("no-elf-hash-table-library.so", RTLD_NOW);
233 ASSERT_TRUE(handle == NULL);
234 ASSERT_STREQ("dlopen failed: empty/missing DT_HASH in \"no-elf-hash-table-library.so\" (built with --hash-style=gnu?)", dlerror());
235 }
236 #endif
237 #endif
238
TEST(dlfcn,dlopen_bad_flags)239 TEST(dlfcn, dlopen_bad_flags) {
240 dlerror(); // Clear any pending errors.
241 void* handle;
242
243 #if defined(__GLIBC__)
244 // glibc was smart enough not to define RTLD_NOW as 0, so it can detect missing flags.
245 handle = dlopen(NULL, 0);
246 ASSERT_TRUE(handle == NULL);
247 ASSERT_SUBSTR("invalid", dlerror());
248 #endif
249
250 handle = dlopen(NULL, 0xffffffff);
251 ASSERT_TRUE(handle == NULL);
252 ASSERT_SUBSTR("invalid", dlerror());
253
254 // glibc actually allows you to choose both RTLD_NOW and RTLD_LAZY at the same time, and so do we.
255 handle = dlopen(NULL, RTLD_NOW|RTLD_LAZY);
256 ASSERT_TRUE(handle != NULL);
257 ASSERT_SUBSTR(NULL, dlerror());
258 }
259
TEST(dlfcn,rtld_default_unknown_symbol)260 TEST(dlfcn, rtld_default_unknown_symbol) {
261 void* addr = dlsym(RTLD_DEFAULT, "ANY_UNKNOWN_SYMBOL_NAME");
262 ASSERT_TRUE(addr == NULL);
263 }
264
TEST(dlfcn,rtld_default_known_symbol)265 TEST(dlfcn, rtld_default_known_symbol) {
266 void* addr = dlsym(RTLD_DEFAULT, "fopen");
267 ASSERT_TRUE(addr != NULL);
268 }
269
TEST(dlfcn,rtld_next_unknown_symbol)270 TEST(dlfcn, rtld_next_unknown_symbol) {
271 void* addr = dlsym(RTLD_NEXT, "ANY_UNKNOWN_SYMBOL_NAME");
272 ASSERT_TRUE(addr == NULL);
273 }
274
TEST(dlfcn,rtld_next_known_symbol)275 TEST(dlfcn, rtld_next_known_symbol) {
276 void* addr = dlsym(RTLD_NEXT, "fopen");
277 ASSERT_TRUE(addr != NULL);
278 }
279
TEST(dlfcn,dlsym_weak_func)280 TEST(dlfcn, dlsym_weak_func) {
281 dlerror();
282 void* handle = dlopen("libtest_dlsym_weak_func.so",RTLD_NOW);
283 ASSERT_TRUE(handle != NULL);
284
285 int (*weak_func)();
286 weak_func = reinterpret_cast<int (*)()>(dlsym(handle, "weak_func"));
287 ASSERT_TRUE(weak_func != NULL) << "dlerror: " << dlerror();
288 EXPECT_EQ(42, weak_func());
289 dlclose(handle);
290 }
291
TEST(dlfcn,dlopen_symlink)292 TEST(dlfcn, dlopen_symlink) {
293 void* handle1 = dlopen("libdlext_test.so", RTLD_NOW);
294 void* handle2 = dlopen("libdlext_test_v2.so", RTLD_NOW);
295 ASSERT_TRUE(handle1 != NULL);
296 ASSERT_TRUE(handle2 != NULL);
297 ASSERT_EQ(handle1, handle2);
298 }
299