dlfcn_test.cpp revision f439b5a3186ca0fef1092f45770abc716da9d87a
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 "private/ScopeGuard.h" 26 27#include <string> 28 29#include "utils.h" 30 31#define ASSERT_SUBSTR(needle, haystack) \ 32 ASSERT_PRED_FORMAT2(::testing::IsSubstring, needle, haystack) 33 34 35static bool g_called = false; 36extern "C" void DlSymTestFunction() { 37 g_called = true; 38} 39 40static int g_ctor_function_called = 0; 41 42extern "C" void ctor_function() __attribute__ ((constructor)); 43 44extern "C" void ctor_function() { 45 g_ctor_function_called = 17; 46} 47 48TEST(dlfcn, ctor_function_call) { 49 ASSERT_EQ(17, g_ctor_function_called); 50} 51 52TEST(dlfcn, dlsym_in_executable) { 53 dlerror(); // Clear any pending errors. 54 void* self = dlopen(NULL, RTLD_NOW); 55 ASSERT_TRUE(self != NULL); 56 ASSERT_TRUE(dlerror() == NULL); 57 58 void* sym = dlsym(self, "DlSymTestFunction"); 59 ASSERT_TRUE(sym != NULL); 60 61 void (*function)() = reinterpret_cast<void(*)()>(sym); 62 63 g_called = false; 64 function(); 65 ASSERT_TRUE(g_called); 66 67 ASSERT_EQ(0, dlclose(self)); 68} 69 70TEST(dlfcn, dlsym_from_sofile) { 71 void* handle = dlopen("libtest_dlsym_from_this.so", RTLD_LAZY | RTLD_LOCAL); 72 ASSERT_TRUE(handle != nullptr) << dlerror(); 73 74 // check that we can't find '_test_dlsym_symbol' via dlsym(RTLD_DEFAULT) 75 void* symbol = dlsym(RTLD_DEFAULT, "test_dlsym_symbol"); 76 ASSERT_TRUE(symbol == nullptr); 77 ASSERT_SUBSTR("undefined symbol: test_dlsym_symbol", dlerror()); 78 79 typedef int* (*fn_t)(); 80 fn_t lookup_dlsym_symbol_using_RTLD_DEFAULT = 81 reinterpret_cast<fn_t>(dlsym(handle, "lookup_dlsym_symbol_using_RTLD_DEFAULT")); 82 ASSERT_TRUE(lookup_dlsym_symbol_using_RTLD_DEFAULT != nullptr) << dlerror(); 83 84 int* ptr = lookup_dlsym_symbol_using_RTLD_DEFAULT(); 85 ASSERT_TRUE(ptr != nullptr) << dlerror(); 86 ASSERT_EQ(42, *ptr); 87 88 fn_t lookup_dlsym_symbol2_using_RTLD_DEFAULT = 89 reinterpret_cast<fn_t>(dlsym(handle, "lookup_dlsym_symbol2_using_RTLD_DEFAULT")); 90 ASSERT_TRUE(lookup_dlsym_symbol2_using_RTLD_DEFAULT != nullptr) << dlerror(); 91 92 ptr = lookup_dlsym_symbol2_using_RTLD_DEFAULT(); 93 ASSERT_TRUE(ptr != nullptr) << dlerror(); 94 ASSERT_EQ(44, *ptr); 95 96 fn_t lookup_dlsym_symbol_using_RTLD_NEXT = 97 reinterpret_cast<fn_t>(dlsym(handle, "lookup_dlsym_symbol_using_RTLD_NEXT")); 98 ASSERT_TRUE(lookup_dlsym_symbol_using_RTLD_NEXT != nullptr) << dlerror(); 99 100 ptr = lookup_dlsym_symbol_using_RTLD_NEXT(); 101 ASSERT_TRUE(ptr != nullptr) << dlerror(); 102 ASSERT_EQ(43, *ptr); 103 104 dlclose(handle); 105} 106 107TEST(dlfcn, dlsym_from_sofile_with_preload) { 108 void* preload = dlopen("libtest_dlsym_from_this_grandchild.so", RTLD_NOW | RTLD_LOCAL); 109 ASSERT_TRUE(preload != nullptr) << dlerror(); 110 111 void* handle = dlopen("libtest_dlsym_from_this.so", RTLD_NOW | RTLD_LOCAL); 112 ASSERT_TRUE(handle != nullptr) << dlerror(); 113 114 // check that we can't find '_test_dlsym_symbol' via dlsym(RTLD_DEFAULT) 115 void* symbol = dlsym(RTLD_DEFAULT, "test_dlsym_symbol"); 116 ASSERT_TRUE(symbol == nullptr); 117 ASSERT_SUBSTR("undefined symbol: test_dlsym_symbol", dlerror()); 118 119 typedef int* (*fn_t)(); 120 fn_t lookup_dlsym_symbol_using_RTLD_DEFAULT = 121 reinterpret_cast<fn_t>(dlsym(handle, "lookup_dlsym_symbol_using_RTLD_DEFAULT")); 122 ASSERT_TRUE(lookup_dlsym_symbol_using_RTLD_DEFAULT != nullptr) << dlerror(); 123 124 int* ptr = lookup_dlsym_symbol_using_RTLD_DEFAULT(); 125 ASSERT_TRUE(ptr != nullptr) << dlerror(); 126 ASSERT_EQ(42, *ptr); 127 128 fn_t lookup_dlsym_symbol2_using_RTLD_DEFAULT = 129 reinterpret_cast<fn_t>(dlsym(handle, "lookup_dlsym_symbol2_using_RTLD_DEFAULT")); 130 ASSERT_TRUE(lookup_dlsym_symbol2_using_RTLD_DEFAULT != nullptr) << dlerror(); 131 132 ptr = lookup_dlsym_symbol2_using_RTLD_DEFAULT(); 133 ASSERT_TRUE(ptr != nullptr) << dlerror(); 134 ASSERT_EQ(44, *ptr); 135 136 fn_t lookup_dlsym_symbol_using_RTLD_NEXT = 137 reinterpret_cast<fn_t>(dlsym(handle, "lookup_dlsym_symbol_using_RTLD_NEXT")); 138 ASSERT_TRUE(lookup_dlsym_symbol_using_RTLD_NEXT != nullptr) << dlerror(); 139 140 ptr = lookup_dlsym_symbol_using_RTLD_NEXT(); 141 ASSERT_TRUE(ptr != nullptr) << dlerror(); 142 ASSERT_EQ(43, *ptr); 143 144 dlclose(handle); 145 dlclose(preload); 146} 147 148TEST(dlfcn, dlsym_handle_global_sym) { 149 // check that we do not look into global group 150 // when looking up symbol by handle 151 void* handle = dlopen("libtest_empty.so", RTLD_NOW); 152 dlopen("libtest_with_dependency.so", RTLD_NOW | RTLD_GLOBAL); 153 void* sym = dlsym(handle, "getRandomNumber"); 154 ASSERT_TRUE(sym == nullptr); 155 ASSERT_SUBSTR("undefined symbol: getRandomNumber", dlerror()); 156 157 sym = dlsym(handle, "DlSymTestFunction"); 158 ASSERT_TRUE(sym == nullptr); 159 ASSERT_SUBSTR("undefined symbol: DlSymTestFunction", dlerror()); 160 dlclose(handle); 161} 162 163TEST(dlfcn, dlsym_with_dependencies) { 164 void* handle = dlopen("libtest_with_dependency.so", RTLD_NOW); 165 ASSERT_TRUE(handle != nullptr); 166 dlerror(); 167 // This symbol is in DT_NEEDED library. 168 void* sym = dlsym(handle, "getRandomNumber"); 169 ASSERT_TRUE(sym != nullptr) << dlerror(); 170 int (*fn)(void); 171 fn = reinterpret_cast<int (*)(void)>(sym); 172 EXPECT_EQ(4, fn()); 173 dlclose(handle); 174} 175 176TEST(dlfcn, dlopen_noload) { 177 void* handle = dlopen("libtest_simple.so", RTLD_NOW | RTLD_NOLOAD); 178 ASSERT_TRUE(handle == NULL); 179 handle = dlopen("libtest_simple.so", RTLD_NOW); 180 void* handle2 = dlopen("libtest_simple.so", RTLD_NOW | RTLD_NOLOAD); 181 ASSERT_TRUE(handle != NULL); 182 ASSERT_TRUE(handle2 != NULL); 183 ASSERT_TRUE(handle == handle2); 184 ASSERT_EQ(0, dlclose(handle)); 185 ASSERT_EQ(0, dlclose(handle2)); 186} 187 188TEST(dlfcn, dlopen_by_soname) { 189 static const char* soname = "libdlext_test_soname.so"; 190 static const char* filename = "libdlext_test_different_soname.so"; 191 // 1. Make sure there is no library with soname in default search path 192 void* handle = dlopen(soname, RTLD_NOW); 193 ASSERT_TRUE(handle == nullptr); 194 195 // 2. Load a library using filename 196 handle = dlopen(filename, RTLD_NOW); 197 ASSERT_TRUE(handle != nullptr) << dlerror(); 198 199 // 3. Find library by soname 200 void* handle_soname = dlopen(soname, RTLD_NOW | RTLD_NOLOAD); 201 ASSERT_TRUE(handle_soname != nullptr) << dlerror(); 202 ASSERT_EQ(handle, handle_soname); 203 204 // 4. RTLD_NOLOAD should still work with filename 205 void* handle_filename = dlopen(filename, RTLD_NOW | RTLD_NOLOAD); 206 ASSERT_TRUE(handle_filename != nullptr) << dlerror(); 207 ASSERT_EQ(handle, handle_filename); 208 209 dlclose(handle_filename); 210 dlclose(handle_soname); 211 dlclose(handle); 212} 213 214// ifuncs are only supported on intel and arm64 for now 215#if defined (__aarch64__) || defined(__i386__) || defined(__x86_64__) 216TEST(dlfcn, ifunc) { 217 typedef const char* (*fn_ptr)(); 218 219 // ifunc's choice depends on whether IFUNC_CHOICE has a value 220 // first check the set case 221 setenv("IFUNC_CHOICE", "set", 1); 222 void* handle = dlopen("libtest_ifunc.so", RTLD_NOW); 223 ASSERT_TRUE(handle != NULL); 224 fn_ptr foo_ptr = reinterpret_cast<fn_ptr>(dlsym(handle, "foo")); 225 fn_ptr foo_library_ptr = reinterpret_cast<fn_ptr>(dlsym(handle, "foo_library")); 226 ASSERT_TRUE(foo_ptr != NULL); 227 ASSERT_TRUE(foo_library_ptr != NULL); 228 ASSERT_EQ(strncmp("set", foo_ptr(), 3), 0); 229 ASSERT_EQ(strncmp("set", foo_library_ptr(), 3), 0); 230 dlclose(handle); 231 232 // then check the unset case 233 unsetenv("IFUNC_CHOICE"); 234 handle = dlopen("libtest_ifunc.so", RTLD_NOW); 235 ASSERT_TRUE(handle != NULL); 236 foo_ptr = reinterpret_cast<fn_ptr>(dlsym(handle, "foo")); 237 foo_library_ptr = reinterpret_cast<fn_ptr>(dlsym(handle, "foo_library")); 238 ASSERT_TRUE(foo_ptr != NULL); 239 ASSERT_TRUE(foo_library_ptr != NULL); 240 ASSERT_EQ(strncmp("unset", foo_ptr(), 5), 0); 241 ASSERT_EQ(strncmp("unset", foo_library_ptr(), 3), 0); 242 dlclose(handle); 243} 244 245TEST(dlfcn, ifunc_ctor_call) { 246 typedef const char* (*fn_ptr)(); 247 248 void* handle = dlopen("libtest_ifunc.so", RTLD_NOW); 249 ASSERT_TRUE(handle != nullptr) << dlerror(); 250 fn_ptr is_ctor_called = reinterpret_cast<fn_ptr>(dlsym(handle, "is_ctor_called_irelative")); 251 ASSERT_TRUE(is_ctor_called != nullptr) << dlerror(); 252 ASSERT_STREQ("false", is_ctor_called()); 253 254 is_ctor_called = reinterpret_cast<fn_ptr>(dlsym(handle, "is_ctor_called_jump_slot")); 255 ASSERT_TRUE(is_ctor_called != nullptr) << dlerror(); 256 ASSERT_STREQ("true", is_ctor_called()); 257 dlclose(handle); 258} 259#endif 260 261TEST(dlfcn, dlopen_check_relocation_dt_needed_order) { 262 // This is the structure of the test library and 263 // its dt_needed libraries 264 // libtest_relo_check_dt_needed_order.so 265 // | 266 // +-> libtest_relo_check_dt_needed_order_1.so 267 // | 268 // +-> libtest_relo_check_dt_needed_order_2.so 269 // 270 // The root library references relo_test_get_answer_lib - which is defined 271 // in both dt_needed libraries, the correct relocation should 272 // use the function defined in libtest_relo_check_dt_needed_order_1.so 273 void* handle = nullptr; 274 auto guard = make_scope_guard([&]() { 275 dlclose(handle); 276 }); 277 278 handle = dlopen("libtest_relo_check_dt_needed_order.so", RTLD_NOW); 279 ASSERT_TRUE(handle != nullptr) << dlerror(); 280 281 typedef int (*fn_t) (void); 282 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "relo_test_get_answer")); 283 ASSERT_TRUE(fn != nullptr) << dlerror(); 284 ASSERT_EQ(1, fn()); 285} 286 287TEST(dlfcn, dlopen_check_order_dlsym) { 288 // Here is how the test library and its dt_needed 289 // libraries are arranged 290 // 291 // libtest_check_order_children.so 292 // | 293 // +-> ..._1_left.so 294 // | | 295 // | +-> ..._a.so 296 // | | 297 // | +-> ...r_b.so 298 // | 299 // +-> ..._2_right.so 300 // | | 301 // | +-> ..._d.so 302 // | | 303 // | +-> ..._b.so 304 // | 305 // +-> ..._3_c.so 306 // 307 // load order should be (1, 2, 3, a, b, d) 308 // 309 // get_answer() is defined in (2, 3, a, b, c) 310 // get_answer2() is defined in (b, d) 311 void* sym = dlsym(RTLD_DEFAULT, "check_order_dlsym_get_answer"); 312 ASSERT_TRUE(sym == nullptr); 313 void* handle = dlopen("libtest_check_order_dlsym.so", RTLD_NOW | RTLD_GLOBAL); 314 ASSERT_TRUE(handle != nullptr) << dlerror(); 315 typedef int (*fn_t) (void); 316 fn_t fn, fn2; 317 fn = reinterpret_cast<fn_t>(dlsym(RTLD_DEFAULT, "check_order_dlsym_get_answer")); 318 ASSERT_TRUE(fn != NULL) << dlerror(); 319 fn2 = reinterpret_cast<fn_t>(dlsym(RTLD_DEFAULT, "check_order_dlsym_get_answer2")); 320 ASSERT_TRUE(fn2 != NULL) << dlerror(); 321 322 ASSERT_EQ(42, fn()); 323 ASSERT_EQ(43, fn2()); 324 dlclose(handle); 325} 326 327TEST(dlfcn, dlopen_check_order_reloc_siblings) { 328 // This is how this one works: 329 // we lookup and call get_answer which is defined in '_2.so' 330 // and in turn calls external get_answer_impl() defined in _1.so and in '_[a-f].so' 331 // the correct _impl() is implemented by '_a.so'; 332 // 333 // Note that this is test for RTLD_LOCAL (TODO: test for GLOBAL?) 334 // 335 // Here is the picture: 336 // 337 // libtest_check_order_reloc_siblings.so 338 // | 339 // +-> ..._1.so <- empty 340 // | | 341 // | +-> ..._a.so <- exports correct answer_impl() 342 // | | 343 // | +-> ..._b.so <- every other letter exporting incorrect one. 344 // | 345 // +-> ..._2.so <- empty 346 // | | 347 // | +-> ..._c.so 348 // | | 349 // | +-> ..._d.so 350 // | 351 // +-> ..._3.so <- empty 352 // | 353 // +-> ..._e.so 354 // | 355 // +-> ..._f.so <- exports get_answer() that calls get_anser_impl(); 356 // implements incorrect get_answer_impl() 357 358 void* handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_NOLOAD); 359 ASSERT_TRUE(handle == nullptr); 360#ifdef __BIONIC__ 361 // TODO: glibc returns nullptr on dlerror() here. Is it bug? 362 ASSERT_STREQ("dlopen failed: library \"libtest_check_order_reloc_siblings.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror()); 363#endif 364 365 handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_LOCAL); 366 ASSERT_TRUE(handle != nullptr) << dlerror(); 367 368 typedef int (*fn_t) (void); 369 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "check_order_reloc_get_answer")); 370 ASSERT_TRUE(fn != nullptr) << dlerror(); 371 ASSERT_EQ(42, fn()); 372 373 ASSERT_EQ(0, dlclose(handle)); 374} 375 376TEST(dlfcn, dlopen_check_order_reloc_siblings_with_preload) { 377 // This test uses the same library as dlopen_check_order_reloc_siblings. 378 // Unlike dlopen_check_order_reloc_siblings it preloads 379 // libtest_check_order_reloc_siblings_1.so (first dependency) prior to 380 // dlopen(libtest_check_order_reloc_siblings.so) 381 382 void* handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_NOLOAD); 383 ASSERT_TRUE(handle == nullptr); 384 handle = dlopen("libtest_check_order_reloc_siblings_1.so", RTLD_NOW | RTLD_NOLOAD); 385 ASSERT_TRUE(handle == nullptr); 386 387 void* handle_for_1 = dlopen("libtest_check_order_reloc_siblings_1.so", RTLD_NOW | RTLD_LOCAL); 388 ASSERT_TRUE(handle_for_1 != nullptr) << dlerror(); 389 390 handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_LOCAL); 391 ASSERT_TRUE(handle != nullptr) << dlerror(); 392 393 ASSERT_EQ(0, dlclose(handle_for_1)); 394 395 typedef int (*fn_t) (void); 396 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "check_order_reloc_get_answer")); 397 ASSERT_TRUE(fn != nullptr) << dlerror(); 398 ASSERT_EQ(42, fn()); 399 400 ASSERT_EQ(0, dlclose(handle)); 401} 402 403TEST(dlfcn, dlopen_check_order_reloc_grandchild) { 404 // This is how this one works: 405 // we lookup and call grandchild_get_answer which is defined in '_2.so' 406 // and in turn calls external get_answer_impl() defined in '_c_1.so and _c_2.so' 407 // the correct _impl() is implemented by '_c_1.so'; 408 // 409 // Here is the picture of subtree: 410 // 411 // libtest_check_order_reloc_siblings.so 412 // | 413 // +-> ..._2.so <- grandchild_get_answer() 414 // | 415 // +-> ..._c.so <- empty 416 // | | 417 // | +-> _c_1.so <- exports correct answer_impl() 418 // | | 419 // | +-> _c_2.so <- exports incorrect answer_impl() 420 // | 421 // +-> ..._d.so <- empty 422 423 void* handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_NOLOAD); 424 ASSERT_TRUE(handle == nullptr); 425#ifdef __BIONIC__ 426 // TODO: glibc returns nullptr on dlerror() here. Is it bug? 427 ASSERT_STREQ("dlopen failed: library \"libtest_check_order_reloc_siblings.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror()); 428#endif 429 430 handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_LOCAL); 431 ASSERT_TRUE(handle != nullptr) << dlerror(); 432 433 typedef int (*fn_t) (void); 434 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "check_order_reloc_grandchild_get_answer")); 435 ASSERT_TRUE(fn != nullptr) << dlerror(); 436 ASSERT_EQ(42, fn()); 437 438 ASSERT_EQ(0, dlclose(handle)); 439} 440 441TEST(dlfcn, dlopen_check_order_reloc_nephew) { 442 // This is how this one works: 443 // we lookup and call nephew_get_answer which is defined in '_2.so' 444 // and in turn calls external get_answer_impl() defined in '_[a-f].so' 445 // the correct _impl() is implemented by '_a.so'; 446 // 447 // Here is the picture: 448 // 449 // libtest_check_order_reloc_siblings.so 450 // | 451 // +-> ..._1.so <- empty 452 // | | 453 // | +-> ..._a.so <- exports correct answer_impl() 454 // | | 455 // | +-> ..._b.so <- every other letter exporting incorrect one. 456 // | 457 // +-> ..._2.so <- empty 458 // | | 459 // | +-> ..._c.so 460 // | | 461 // | +-> ..._d.so 462 // | 463 // +-> ..._3.so <- nephew_get_answer() that calls get_answer_impl(); 464 // | 465 // +-> ..._e.so 466 // | 467 // +-> ..._f.so 468 469 void* handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_NOLOAD); 470 ASSERT_TRUE(handle == nullptr); 471#ifdef __BIONIC__ 472 // TODO: glibc returns nullptr on dlerror() here. Is it bug? 473 ASSERT_STREQ("dlopen failed: library \"libtest_check_order_reloc_siblings.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror()); 474#endif 475 476 handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_LOCAL); 477 ASSERT_TRUE(handle != nullptr) << dlerror(); 478 479 typedef int (*fn_t) (void); 480 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "check_order_reloc_nephew_get_answer")); 481 ASSERT_TRUE(fn != nullptr) << dlerror(); 482 ASSERT_EQ(42, fn()); 483 484 ASSERT_EQ(0, dlclose(handle)); 485} 486 487TEST(dlfcn, check_unload_after_reloc) { 488 // This is how this one works: 489 // libtest_two_parents_parent1 <- answer_impl() used by libtest_two_parents_child 490 // | 491 // +-> libtest_two_parents_child 492 // 493 // libtest_two_parents_parent2 <- answer_impl() not used by libtest_two_parents_child 494 // | 495 // +-> libtest_two_parents_child 496 // 497 // Test dlopens parent1 which loads and relocates libtest_two_parents_child.so 498 // as a second step it dlopens parent2 and dlcloses parent1... 499 500 void* handle = dlopen("libtest_two_parents_parent1.so", RTLD_NOW | RTLD_LOCAL); 501 ASSERT_TRUE(handle != nullptr) << dlerror(); 502 503 void* handle2 = dlopen("libtest_two_parents_parent2.so", RTLD_NOW | RTLD_LOCAL); 504 ASSERT_TRUE(handle2 != nullptr) << dlerror(); 505 506 typedef int (*fn_t) (void); 507 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle2, "check_order_reloc_get_answer")); 508 ASSERT_TRUE(fn != nullptr) << dlerror(); 509 ASSERT_EQ(42, fn()); 510 511 ASSERT_EQ(0, dlclose(handle)); 512 513 handle = dlopen("libtest_two_parents_parent1.so", RTLD_NOW | RTLD_LOCAL | RTLD_NOLOAD); 514 ASSERT_TRUE(handle != nullptr); 515 ASSERT_EQ(0, dlclose(handle)); 516 517 fn = reinterpret_cast<fn_t>(dlsym(handle2, "check_order_reloc_get_answer")); 518 ASSERT_TRUE(fn != nullptr) << dlerror(); 519 ASSERT_EQ(42, fn()); 520 521 ASSERT_EQ(0, dlclose(handle2)); 522 523 handle = dlopen("libtest_two_parents_parent1.so", RTLD_NOW | RTLD_LOCAL | RTLD_NOLOAD); 524 ASSERT_TRUE(handle == nullptr); 525} 526 527extern "C" int check_order_reloc_root_get_answer_impl() { 528 return 42; 529} 530 531TEST(dlfcn, dlopen_check_order_reloc_main_executable) { 532 // This is how this one works: 533 // we lookup and call get_answer3 which is defined in 'root.so' 534 // and in turn calls external root_get_answer_impl() defined in _2.so and 535 // above the correct _impl() is one in the executable. 536 // 537 // libtest_check_order_reloc_root.so 538 // | 539 // +-> ..._1.so <- empty 540 // | 541 // +-> ..._2.so <- gives incorrect answer for answer_main_impl() 542 // 543 544 void* handle = dlopen("libtest_check_order_reloc_root.so", RTLD_NOW | RTLD_NOLOAD); 545 ASSERT_TRUE(handle == nullptr); 546#ifdef __BIONIC__ 547 // TODO: glibc returns nullptr on dlerror() here. Is it bug? 548 ASSERT_STREQ("dlopen failed: library \"libtest_check_order_reloc_root.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror()); 549#endif 550 551 handle = dlopen("libtest_check_order_reloc_root.so", RTLD_NOW | RTLD_LOCAL); 552 ASSERT_TRUE(handle != nullptr) << dlerror(); 553 554 typedef int (*fn_t) (void); 555 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "check_order_reloc_root_get_answer")); 556 ASSERT_TRUE(fn != nullptr) << dlerror(); 557 ASSERT_EQ(42, fn()); 558 559 ASSERT_EQ(0, dlclose(handle)); 560} 561 562TEST(dlfcn, dlopen_check_rtld_local) { 563 void* sym = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); 564 ASSERT_TRUE(sym == nullptr); 565 566 // implicit RTLD_LOCAL 567 void* handle = dlopen("libtest_simple.so", RTLD_NOW); 568 sym = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); 569 ASSERT_TRUE(sym == nullptr); 570 ASSERT_SUBSTR("undefined symbol: dlopen_testlib_simple_func", dlerror()); 571 sym = dlsym(handle, "dlopen_testlib_simple_func"); 572 ASSERT_TRUE(sym != nullptr); 573 ASSERT_TRUE(reinterpret_cast<bool (*)(void)>(sym)()); 574 dlclose(handle); 575 576 // explicit RTLD_LOCAL 577 handle = dlopen("libtest_simple.so", RTLD_NOW | RTLD_LOCAL); 578 sym = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); 579 ASSERT_TRUE(sym == nullptr); 580 ASSERT_SUBSTR("undefined symbol: dlopen_testlib_simple_func", dlerror()); 581 sym = dlsym(handle, "dlopen_testlib_simple_func"); 582 ASSERT_TRUE(sym != nullptr); 583 ASSERT_TRUE(reinterpret_cast<bool (*)(void)>(sym)()); 584 dlclose(handle); 585} 586 587TEST(dlfcn, dlopen_check_rtld_global) { 588 void* sym = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); 589 ASSERT_TRUE(sym == nullptr); 590 591 void* handle = dlopen("libtest_simple.so", RTLD_NOW | RTLD_GLOBAL); 592 ASSERT_TRUE(handle != nullptr) << dlerror(); 593 sym = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); 594 ASSERT_TRUE(sym != nullptr) << dlerror(); 595 ASSERT_TRUE(reinterpret_cast<bool (*)(void)>(sym)()); 596 dlclose(handle); 597 598 // RTLD_GLOBAL implies RTLD_NODELETE, let's check that 599 void* sym_after_dlclose = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); 600 ASSERT_EQ(sym, sym_after_dlclose); 601 602 // Check if dlsym() for main program's handle searches RTLD_GLOBAL 603 // shared libraries after symbol was not found in the main executable 604 // and dependent libraries. 605 void* handle_for_main_executable = dlopen(nullptr, RTLD_NOW); 606 sym = dlsym(handle_for_main_executable, "dlopen_testlib_simple_func"); 607 ASSERT_TRUE(sym != nullptr) << dlerror(); 608 609 dlclose(handle_for_main_executable); 610} 611 612// libtest_with_dependency_loop.so -> libtest_with_dependency_loop_a.so -> 613// libtest_with_dependency_loop_b.so -> libtest_with_dependency_loop_c.so -> 614// libtest_with_dependency_loop_a.so 615TEST(dlfcn, dlopen_check_loop) { 616 void* handle = dlopen("libtest_with_dependency_loop.so", RTLD_NOW); 617 ASSERT_TRUE(handle != nullptr) << dlerror(); 618 void* f = dlsym(handle, "dlopen_test_loopy_function"); 619 ASSERT_TRUE(f != nullptr) << dlerror(); 620 EXPECT_TRUE(reinterpret_cast<bool (*)(void)>(f)()); 621 ASSERT_EQ(0, dlclose(handle)); 622 623 // dlopen second time to make sure that the library was unloaded correctly 624 handle = dlopen("libtest_with_dependency_loop.so", RTLD_NOW | RTLD_NOLOAD); 625 ASSERT_TRUE(handle == nullptr); 626#ifdef __BIONIC__ 627 // TODO: glibc returns nullptr on dlerror() here. Is it bug? 628 ASSERT_STREQ("dlopen failed: library \"libtest_with_dependency_loop.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror()); 629#endif 630 631 handle = dlopen("libtest_with_dependency_a.so", RTLD_NOW | RTLD_NOLOAD); 632 ASSERT_TRUE(handle == nullptr); 633} 634 635TEST(dlfcn, dlopen_nodelete) { 636 static bool is_unloaded = false; 637 638 void* handle = dlopen("libtest_nodelete_1.so", RTLD_NOW | RTLD_NODELETE); 639 ASSERT_TRUE(handle != nullptr) << dlerror(); 640 void (*set_unload_flag_ptr)(bool*); 641 set_unload_flag_ptr = reinterpret_cast<void (*)(bool*)>(dlsym(handle, "dlopen_nodelete_1_set_unload_flag_ptr")); 642 ASSERT_TRUE(set_unload_flag_ptr != nullptr) << dlerror(); 643 set_unload_flag_ptr(&is_unloaded); 644 645 uint32_t* taxicab_number = reinterpret_cast<uint32_t*>(dlsym(handle, "dlopen_nodelete_1_taxicab_number")); 646 ASSERT_TRUE(taxicab_number != nullptr) << dlerror(); 647 ASSERT_EQ(1729U, *taxicab_number); 648 *taxicab_number = 2; 649 650 dlclose(handle); 651 ASSERT_TRUE(!is_unloaded); 652 653 uint32_t* taxicab_number_after_dlclose = reinterpret_cast<uint32_t*>(dlsym(handle, "dlopen_nodelete_1_taxicab_number")); 654 ASSERT_EQ(taxicab_number_after_dlclose, taxicab_number); 655 ASSERT_EQ(2U, *taxicab_number_after_dlclose); 656 657 658 handle = dlopen("libtest_nodelete_1.so", RTLD_NOW); 659 uint32_t* taxicab_number2 = reinterpret_cast<uint32_t*>(dlsym(handle, "dlopen_nodelete_1_taxicab_number")); 660 ASSERT_EQ(taxicab_number2, taxicab_number); 661 662 ASSERT_EQ(2U, *taxicab_number2); 663 664 dlclose(handle); 665 ASSERT_TRUE(!is_unloaded); 666} 667 668TEST(dlfcn, dlopen_nodelete_on_second_dlopen) { 669 static bool is_unloaded = false; 670 671 void* handle = dlopen("libtest_nodelete_2.so", RTLD_NOW); 672 ASSERT_TRUE(handle != nullptr) << dlerror(); 673 void (*set_unload_flag_ptr)(bool*); 674 set_unload_flag_ptr = reinterpret_cast<void (*)(bool*)>(dlsym(handle, "dlopen_nodelete_2_set_unload_flag_ptr")); 675 ASSERT_TRUE(set_unload_flag_ptr != nullptr) << dlerror(); 676 set_unload_flag_ptr(&is_unloaded); 677 678 uint32_t* taxicab_number = reinterpret_cast<uint32_t*>(dlsym(handle, "dlopen_nodelete_2_taxicab_number")); 679 ASSERT_TRUE(taxicab_number != nullptr) << dlerror(); 680 681 ASSERT_EQ(1729U, *taxicab_number); 682 *taxicab_number = 2; 683 684 // This RTLD_NODELETE should be ignored 685 void* handle1 = dlopen("libtest_nodelete_2.so", RTLD_NOW | RTLD_NODELETE); 686 ASSERT_TRUE(handle1 != nullptr) << dlerror(); 687 ASSERT_EQ(handle, handle1); 688 689 dlclose(handle1); 690 dlclose(handle); 691 692 ASSERT_TRUE(is_unloaded); 693} 694 695TEST(dlfcn, dlopen_nodelete_dt_flags_1) { 696 static bool is_unloaded = false; 697 698 void* handle = dlopen("libtest_nodelete_dt_flags_1.so", RTLD_NOW); 699 ASSERT_TRUE(handle != nullptr) << dlerror(); 700 void (*set_unload_flag_ptr)(bool*); 701 set_unload_flag_ptr = reinterpret_cast<void (*)(bool*)>(dlsym(handle, "dlopen_nodelete_dt_flags_1_set_unload_flag_ptr")); 702 ASSERT_TRUE(set_unload_flag_ptr != nullptr) << dlerror(); 703 set_unload_flag_ptr(&is_unloaded); 704 705 dlclose(handle); 706 ASSERT_TRUE(!is_unloaded); 707} 708 709TEST(dlfcn, dlsym_df_1_global) { 710 void* handle = dlopen("libtest_dlsym_df_1_global.so", RTLD_NOW); 711 ASSERT_TRUE(handle != nullptr) << dlerror(); 712 int (*get_answer)(); 713 get_answer = reinterpret_cast<int (*)()>(dlsym(handle, "dl_df_1_global_get_answer")); 714 ASSERT_TRUE(get_answer != nullptr) << dlerror(); 715 ASSERT_EQ(42, get_answer()); 716 ASSERT_EQ(0, dlclose(handle)); 717} 718 719TEST(dlfcn, dlopen_failure) { 720 void* self = dlopen("/does/not/exist", RTLD_NOW); 721 ASSERT_TRUE(self == NULL); 722#if defined(__BIONIC__) 723 ASSERT_STREQ("dlopen failed: library \"/does/not/exist\" not found", dlerror()); 724#else 725 ASSERT_STREQ("/does/not/exist: cannot open shared object file: No such file or directory", dlerror()); 726#endif 727} 728 729static void* ConcurrentDlErrorFn(void*) { 730 dlopen("/child/thread", RTLD_NOW); 731 return reinterpret_cast<void*>(strdup(dlerror())); 732} 733 734TEST(dlfcn, dlerror_concurrent) { 735 dlopen("/main/thread", RTLD_NOW); 736 const char* main_thread_error = dlerror(); 737 ASSERT_SUBSTR("/main/thread", main_thread_error); 738 739 pthread_t t; 740 ASSERT_EQ(0, pthread_create(&t, NULL, ConcurrentDlErrorFn, NULL)); 741 void* result; 742 ASSERT_EQ(0, pthread_join(t, &result)); 743 char* child_thread_error = static_cast<char*>(result); 744 ASSERT_SUBSTR("/child/thread", child_thread_error); 745 free(child_thread_error); 746 747 ASSERT_SUBSTR("/main/thread", main_thread_error); 748} 749 750TEST(dlfcn, dlsym_failures) { 751 dlerror(); // Clear any pending errors. 752 void* self = dlopen(NULL, RTLD_NOW); 753 ASSERT_TRUE(self != NULL); 754 ASSERT_TRUE(dlerror() == NULL); 755 756 void* sym; 757 758#if defined(__BIONIC__) && !defined(__LP64__) 759 // RTLD_DEFAULT in lp32 bionic is not (void*)0 760 // so it can be distinguished from the NULL handle. 761 sym = dlsym(NULL, "test"); 762 ASSERT_TRUE(sym == NULL); 763 ASSERT_SUBSTR("dlsym library handle is null", dlerror()); 764#endif 765 766 // NULL symbol name. 767#if defined(__BIONIC__) 768 // glibc marks this parameter non-null and SEGVs if you cheat. 769 sym = dlsym(self, NULL); 770 ASSERT_TRUE(sym == NULL); 771 ASSERT_SUBSTR("", dlerror()); 772#endif 773 774 // Symbol that doesn't exist. 775 sym = dlsym(self, "ThisSymbolDoesNotExist"); 776 ASSERT_TRUE(sym == NULL); 777 ASSERT_SUBSTR("undefined symbol: ThisSymbolDoesNotExist", dlerror()); 778 779 ASSERT_EQ(0, dlclose(self)); 780} 781 782TEST(dlfcn, dladdr_executable) { 783 dlerror(); // Clear any pending errors. 784 void* self = dlopen(NULL, RTLD_NOW); 785 ASSERT_TRUE(self != NULL); 786 ASSERT_TRUE(dlerror() == NULL); 787 788 void* sym = dlsym(self, "DlSymTestFunction"); 789 ASSERT_TRUE(sym != NULL); 790 791 // Deliberately ask dladdr for an address inside a symbol, rather than the symbol base address. 792 void* addr = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(sym) + 2); 793 794 Dl_info info; 795 int rc = dladdr(addr, &info); 796 ASSERT_NE(rc, 0); // Zero on error, non-zero on success. 797 798 // Get the name of this executable. 799 char executable_path[PATH_MAX]; 800 rc = readlink("/proc/self/exe", executable_path, sizeof(executable_path)); 801 ASSERT_NE(rc, -1); 802 executable_path[rc] = '\0'; 803 804 // The filename should be that of this executable. 805 char dli_realpath[PATH_MAX]; 806 ASSERT_TRUE(realpath(info.dli_fname, dli_realpath) != nullptr); 807 ASSERT_STREQ(executable_path, dli_realpath); 808 809 // The symbol name should be the symbol we looked up. 810 ASSERT_STREQ(info.dli_sname, "DlSymTestFunction"); 811 812 // The address should be the exact address of the symbol. 813 ASSERT_EQ(info.dli_saddr, sym); 814 815 std::vector<map_record> maps; 816 ASSERT_TRUE(Maps::parse_maps(&maps)); 817 818 void* base_address = nullptr; 819 for (const map_record& rec : maps) { 820 if (executable_path == rec.pathname) { 821 base_address = reinterpret_cast<void*>(rec.addr_start); 822 break; 823 } 824 } 825 826 // The base address should be the address we were loaded at. 827 ASSERT_EQ(info.dli_fbase, base_address); 828 829 ASSERT_EQ(0, dlclose(self)); 830} 831 832#if defined(__LP64__) 833#define BIONIC_PATH_TO_LIBC "/system/lib64/libc.so" 834#else 835#define BIONIC_PATH_TO_LIBC "/system/lib/libc.so" 836#endif 837 838TEST(dlfcn, dladdr_libc) { 839#if defined(__BIONIC__) 840 Dl_info info; 841 void* addr = reinterpret_cast<void*>(puts); // well-known libc function 842 ASSERT_TRUE(dladdr(addr, &info) != 0); 843 844 // /system/lib is symlink when this test is executed on host. 845 char libc_realpath[PATH_MAX]; 846 ASSERT_TRUE(realpath(BIONIC_PATH_TO_LIBC, libc_realpath) == libc_realpath); 847 848 ASSERT_STREQ(libc_realpath, info.dli_fname); 849 // TODO: add check for dfi_fbase 850 ASSERT_STREQ("puts", info.dli_sname); 851 ASSERT_EQ(addr, info.dli_saddr); 852#else 853 GTEST_LOG_(INFO) << "This test does nothing for glibc. Glibc returns path from ldconfig " 854 "for libc.so, which is symlink itself (not a realpath).\n"; 855#endif 856} 857 858TEST(dlfcn, dladdr_invalid) { 859 Dl_info info; 860 861 dlerror(); // Clear any pending errors. 862 863 // No symbol corresponding to NULL. 864 ASSERT_EQ(dladdr(NULL, &info), 0); // Zero on error, non-zero on success. 865 ASSERT_TRUE(dlerror() == NULL); // dladdr(3) doesn't set dlerror(3). 866 867 // No symbol corresponding to a stack address. 868 ASSERT_EQ(dladdr(&info, &info), 0); // Zero on error, non-zero on success. 869 ASSERT_TRUE(dlerror() == NULL); // dladdr(3) doesn't set dlerror(3). 870} 871 872// GNU-style ELF hash tables are incompatible with the MIPS ABI. 873// MIPS requires .dynsym to be sorted to match the GOT but GNU-style requires sorting by hash code. 874TEST(dlfcn, dlopen_library_with_only_gnu_hash) { 875#if !defined(__mips__) 876 dlerror(); // Clear any pending errors. 877 void* handle = dlopen("libgnu-hash-table-library.so", RTLD_NOW); 878 ASSERT_TRUE(handle != nullptr) << dlerror(); 879 auto guard = make_scope_guard([&]() { 880 dlclose(handle); 881 }); 882 void* sym = dlsym(handle, "getRandomNumber"); 883 ASSERT_TRUE(sym != nullptr) << dlerror(); 884 int (*fn)(void); 885 fn = reinterpret_cast<int (*)(void)>(sym); 886 EXPECT_EQ(4, fn()); 887 888 Dl_info dlinfo; 889 ASSERT_TRUE(0 != dladdr(reinterpret_cast<void*>(fn), &dlinfo)); 890 891 ASSERT_TRUE(fn == dlinfo.dli_saddr); 892 ASSERT_STREQ("getRandomNumber", dlinfo.dli_sname); 893 ASSERT_SUBSTR("libgnu-hash-table-library.so", dlinfo.dli_fname); 894#else 895 GTEST_LOG_(INFO) << "This test does nothing for mips/mips64; mips toolchain does not support '--hash-style=gnu'\n"; 896#endif 897} 898 899TEST(dlfcn, dlopen_library_with_only_sysv_hash) { 900 void* handle = dlopen("libsysv-hash-table-library.so", RTLD_NOW); 901 ASSERT_TRUE(handle != nullptr) << dlerror(); 902 auto guard = make_scope_guard([&]() { 903 dlclose(handle); 904 }); 905 void* sym = dlsym(handle, "getRandomNumber"); 906 ASSERT_TRUE(sym != nullptr) << dlerror(); 907 int (*fn)(void); 908 fn = reinterpret_cast<int (*)(void)>(sym); 909 EXPECT_EQ(4, fn()); 910 911 Dl_info dlinfo; 912 ASSERT_TRUE(0 != dladdr(reinterpret_cast<void*>(fn), &dlinfo)); 913 914 ASSERT_TRUE(fn == dlinfo.dli_saddr); 915 ASSERT_STREQ("getRandomNumber", dlinfo.dli_sname); 916 ASSERT_SUBSTR("libsysv-hash-table-library.so", dlinfo.dli_fname); 917} 918 919TEST(dlfcn, dlopen_bad_flags) { 920 dlerror(); // Clear any pending errors. 921 void* handle; 922 923#if defined(__GLIBC__) 924 // glibc was smart enough not to define RTLD_NOW as 0, so it can detect missing flags. 925 handle = dlopen(NULL, 0); 926 ASSERT_TRUE(handle == NULL); 927 ASSERT_SUBSTR("invalid", dlerror()); 928#endif 929 930 handle = dlopen(NULL, 0xffffffff); 931 ASSERT_TRUE(handle == NULL); 932 ASSERT_SUBSTR("invalid", dlerror()); 933 934 // glibc actually allows you to choose both RTLD_NOW and RTLD_LAZY at the same time, and so do we. 935 handle = dlopen(NULL, RTLD_NOW|RTLD_LAZY); 936 ASSERT_TRUE(handle != NULL); 937 ASSERT_SUBSTR(NULL, dlerror()); 938} 939 940TEST(dlfcn, rtld_default_unknown_symbol) { 941 void* addr = dlsym(RTLD_DEFAULT, "ANY_UNKNOWN_SYMBOL_NAME"); 942 ASSERT_TRUE(addr == NULL); 943} 944 945TEST(dlfcn, rtld_default_known_symbol) { 946 void* addr = dlsym(RTLD_DEFAULT, "fopen"); 947 ASSERT_TRUE(addr != NULL); 948} 949 950TEST(dlfcn, rtld_next_unknown_symbol) { 951 void* addr = dlsym(RTLD_NEXT, "ANY_UNKNOWN_SYMBOL_NAME"); 952 ASSERT_TRUE(addr == NULL); 953} 954 955TEST(dlfcn, rtld_next_known_symbol) { 956 void* addr = dlsym(RTLD_NEXT, "fopen"); 957 ASSERT_TRUE(addr != NULL); 958} 959 960TEST(dlfcn, dlsym_weak_func) { 961 dlerror(); 962 void* handle = dlopen("libtest_dlsym_weak_func.so", RTLD_NOW); 963 ASSERT_TRUE(handle != NULL); 964 965 int (*weak_func)(); 966 weak_func = reinterpret_cast<int (*)()>(dlsym(handle, "weak_func")); 967 ASSERT_TRUE(weak_func != NULL) << "dlerror: " << dlerror(); 968 EXPECT_EQ(42, weak_func()); 969 dlclose(handle); 970} 971 972TEST(dlfcn, dlopen_undefined_weak_func) { 973 void* handle = dlopen("libtest_dlopen_weak_undefined_func.so", RTLD_NOW); 974 ASSERT_TRUE(handle != nullptr) << dlerror(); 975 int (*weak_func)(); 976 weak_func = reinterpret_cast<int (*)()>(dlsym(handle, "use_weak_undefined_func")); 977 ASSERT_TRUE(weak_func != nullptr) << dlerror(); 978 EXPECT_EQ(6551, weak_func()); 979 dlclose(handle); 980} 981 982TEST(dlfcn, dlopen_symlink) { 983 void* handle1 = dlopen("libdlext_test.so", RTLD_NOW); 984 void* handle2 = dlopen("libdlext_test_v2.so", RTLD_NOW); 985 ASSERT_TRUE(handle1 != NULL); 986 ASSERT_TRUE(handle2 != NULL); 987 ASSERT_EQ(handle1, handle2); 988 dlclose(handle1); 989 dlclose(handle2); 990} 991 992// libtest_dlopen_from_ctor_main.so depends on 993// libtest_dlopen_from_ctor.so which has a constructor 994// that calls dlopen(libc...). This is to test the situation 995// described in b/7941716. 996TEST(dlfcn, dlopen_dlopen_from_ctor) { 997#if defined(__BIONIC__) 998 void* handle = dlopen("libtest_dlopen_from_ctor_main.so", RTLD_NOW); 999 ASSERT_TRUE(handle != nullptr) << dlerror(); 1000 dlclose(handle); 1001#else 1002 GTEST_LOG_(INFO) << "This test is disabled for glibc (glibc segfaults if you try to call dlopen from a constructor).\n"; 1003#endif 1004} 1005 1006TEST(dlfcn, symbol_versioning_use_v1) { 1007 void* handle = dlopen("libtest_versioned_uselibv1.so", RTLD_NOW); 1008 ASSERT_TRUE(handle != nullptr) << dlerror(); 1009 typedef int (*fn_t)(); 1010 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "get_function_version")); 1011 ASSERT_TRUE(fn != nullptr) << dlerror(); 1012 ASSERT_EQ(1, fn()); 1013 dlclose(handle); 1014} 1015 1016TEST(dlfcn, symbol_versioning_use_v2) { 1017 void* handle = dlopen("libtest_versioned_uselibv2.so", RTLD_NOW); 1018 ASSERT_TRUE(handle != nullptr) << dlerror(); 1019 typedef int (*fn_t)(); 1020 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "get_function_version")); 1021 ASSERT_TRUE(fn != nullptr) << dlerror(); 1022 ASSERT_EQ(2, fn()); 1023 dlclose(handle); 1024} 1025 1026TEST(dlfcn, symbol_versioning_use_other_v2) { 1027 void* handle = dlopen("libtest_versioned_uselibv2_other.so", RTLD_NOW); 1028 ASSERT_TRUE(handle != nullptr) << dlerror(); 1029 typedef int (*fn_t)(); 1030 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "get_function_version")); 1031 ASSERT_TRUE(fn != nullptr) << dlerror(); 1032 ASSERT_EQ(20, fn()); 1033 dlclose(handle); 1034} 1035 1036TEST(dlfcn, symbol_versioning_use_other_v3) { 1037 void* handle = dlopen("libtest_versioned_uselibv3_other.so", RTLD_NOW); 1038 ASSERT_TRUE(handle != nullptr) << dlerror(); 1039 typedef int (*fn_t)(); 1040 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "get_function_version")); 1041 ASSERT_TRUE(fn != nullptr) << dlerror(); 1042 ASSERT_EQ(3, fn()); 1043 dlclose(handle); 1044} 1045 1046TEST(dlfcn, symbol_versioning_default_via_dlsym) { 1047 void* handle = dlopen("libtest_versioned_lib.so", RTLD_NOW); 1048 ASSERT_TRUE(handle != nullptr) << dlerror(); 1049 typedef int (*fn_t)(); 1050 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "versioned_function")); 1051 ASSERT_TRUE(fn != nullptr) << dlerror(); 1052 ASSERT_EQ(3, fn()); // the default version is 3 1053 dlclose(handle); 1054} 1055 1056// This preempts the implementation from libtest_versioned_lib.so 1057extern "C" int version_zero_function() { 1058 return 0; 1059} 1060 1061// This preempts the implementation from libtest_versioned_uselibv*.so 1062extern "C" int version_zero_function2() { 1063 return 0; 1064} 1065