1/*
2 * Copyright (C) 2014 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 <elf.h>
21#include <errno.h>
22#include <fcntl.h>
23#include <inttypes.h>
24#include <stdio.h>
25#include <string.h>
26#include <unistd.h>
27#include <android/dlext.h>
28#include <sys/mman.h>
29#include <sys/types.h>
30#include <sys/wait.h>
31
32#include <pagemap/pagemap.h>
33#include <ziparchive/zip_archive.h>
34
35#include "TemporaryFile.h"
36#include "utils.h"
37#include "dlext_private.h"
38
39#define ASSERT_DL_NOTNULL(ptr) \
40    ASSERT_TRUE(ptr != nullptr) << "dlerror: " << dlerror()
41
42#define ASSERT_DL_ZERO(i) \
43    ASSERT_EQ(0, i) << "dlerror: " << dlerror()
44
45#define ASSERT_NOERROR(i) \
46    ASSERT_NE(-1, i) << "errno: " << strerror(errno)
47
48#define ASSERT_SUBSTR(needle, haystack) \
49    ASSERT_PRED_FORMAT2(::testing::IsSubstring, needle, haystack)
50
51
52typedef int (*fn)(void);
53#define LIBNAME "libdlext_test.so"
54#define LIBNAME_NORELRO "libdlext_test_norelro.so"
55#define LIBSIZE 1024*1024 // how much address space to reserve for it
56
57#if defined(__LP64__)
58#define NATIVE_TESTS_PATH "/nativetest64"
59#else
60#define NATIVE_TESTS_PATH "/nativetest"
61#endif
62
63#define LIBPATH NATIVE_TESTS_PATH "/libdlext_test_fd/libdlext_test_fd.so"
64#define LIBZIPPATH NATIVE_TESTS_PATH "/libdlext_test_zip/libdlext_test_zip_zipaligned.zip"
65#define LIBZIPPATH_WITH_RUNPATH NATIVE_TESTS_PATH "/libdlext_test_runpath_zip/libdlext_test_runpath_zip_zipaligned.zip"
66#define LIBZIP_SIMPLE_ZIP "libdir/libatest_simple_zip.so"
67
68class DlExtTest : public ::testing::Test {
69protected:
70  virtual void SetUp() {
71    handle_ = nullptr;
72    // verify that we don't have the library loaded already
73    void* h = dlopen(LIBNAME, RTLD_NOW | RTLD_NOLOAD);
74    ASSERT_TRUE(h == nullptr);
75    h = dlopen(LIBNAME_NORELRO, RTLD_NOW | RTLD_NOLOAD);
76    ASSERT_TRUE(h == nullptr);
77    // call dlerror() to swallow the error, and check it was the one we wanted
78    ASSERT_STREQ("dlopen failed: library \"" LIBNAME_NORELRO "\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror());
79  }
80
81  virtual void TearDown() {
82    if (handle_ != nullptr) {
83      ASSERT_DL_ZERO(dlclose(handle_));
84    }
85  }
86
87  void* handle_;
88};
89
90TEST_F(DlExtTest, ExtInfoNull) {
91  handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, nullptr);
92  ASSERT_DL_NOTNULL(handle_);
93  fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
94  ASSERT_DL_NOTNULL(f);
95  EXPECT_EQ(4, f());
96}
97
98TEST_F(DlExtTest, ExtInfoNoFlags) {
99  android_dlextinfo extinfo;
100  extinfo.flags = 0;
101  handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
102  ASSERT_DL_NOTNULL(handle_);
103  fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
104  ASSERT_DL_NOTNULL(f);
105  EXPECT_EQ(4, f());
106}
107
108TEST_F(DlExtTest, ExtInfoUseFd) {
109  const std::string lib_path = std::string(getenv("ANDROID_DATA")) + LIBPATH;
110
111  android_dlextinfo extinfo;
112  extinfo.flags = ANDROID_DLEXT_USE_LIBRARY_FD;
113  extinfo.library_fd = TEMP_FAILURE_RETRY(open(lib_path.c_str(), O_RDONLY | O_CLOEXEC));
114  ASSERT_TRUE(extinfo.library_fd != -1);
115  handle_ = android_dlopen_ext(lib_path.c_str(), RTLD_NOW, &extinfo);
116  ASSERT_DL_NOTNULL(handle_);
117  fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
118  ASSERT_DL_NOTNULL(f);
119  EXPECT_EQ(4, f());
120
121  uint32_t* taxicab_number = reinterpret_cast<uint32_t*>(dlsym(handle_, "dlopen_testlib_taxicab_number"));
122  ASSERT_DL_NOTNULL(taxicab_number);
123  EXPECT_EQ(1729U, *taxicab_number);
124}
125
126TEST_F(DlExtTest, ExtInfoUseFdWithOffset) {
127  const std::string lib_path = std::string(getenv("ANDROID_DATA")) + LIBZIPPATH;
128
129  android_dlextinfo extinfo;
130  extinfo.flags = ANDROID_DLEXT_USE_LIBRARY_FD | ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET;
131  extinfo.library_fd = TEMP_FAILURE_RETRY(open(lib_path.c_str(), O_RDONLY | O_CLOEXEC));
132
133  // Find the offset of the shared library in the zip.
134  ZipArchiveHandle handle;
135  ASSERT_EQ(0, OpenArchive(lib_path.c_str(), &handle));
136  ZipEntry zip_entry;
137  ZipString zip_name;
138  zip_name.name = reinterpret_cast<const uint8_t*>(LIBZIP_SIMPLE_ZIP);
139  zip_name.name_length = sizeof(LIBZIP_SIMPLE_ZIP) - 1;
140  ASSERT_EQ(0, FindEntry(handle, zip_name, &zip_entry));
141  extinfo.library_fd_offset = zip_entry.offset;
142  CloseArchive(handle);
143
144  handle_ = android_dlopen_ext(lib_path.c_str(), RTLD_NOW, &extinfo);
145  ASSERT_DL_NOTNULL(handle_);
146
147  uint32_t* taxicab_number = reinterpret_cast<uint32_t*>(dlsym(handle_, "dlopen_testlib_taxicab_number"));
148  ASSERT_DL_NOTNULL(taxicab_number);
149  EXPECT_EQ(1729U, *taxicab_number);
150}
151
152TEST_F(DlExtTest, ExtInfoUseFdWithInvalidOffset) {
153  const std::string lib_path = std::string(getenv("ANDROID_DATA")) + LIBZIPPATH;
154  // lib_path is relative when $ANDROID_DATA is relative
155  char lib_realpath_buf[PATH_MAX];
156  ASSERT_TRUE(realpath(lib_path.c_str(), lib_realpath_buf) == lib_realpath_buf);
157  const std::string lib_realpath = std::string(lib_realpath_buf);
158
159  android_dlextinfo extinfo;
160  extinfo.flags = ANDROID_DLEXT_USE_LIBRARY_FD | ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET;
161  extinfo.library_fd = TEMP_FAILURE_RETRY(open(lib_path.c_str(), O_RDONLY | O_CLOEXEC));
162  extinfo.library_fd_offset = 17;
163
164  handle_ = android_dlopen_ext("libname_placeholder", RTLD_NOW, &extinfo);
165  ASSERT_TRUE(handle_ == nullptr);
166  ASSERT_STREQ("dlopen failed: file offset for the library \"libname_placeholder\" is not page-aligned: 17", dlerror());
167
168  // Test an address above 2^44, for http://b/18178121 .
169  extinfo.library_fd_offset = (5LL<<48) + PAGE_SIZE;
170  handle_ = android_dlopen_ext("libname_placeholder", RTLD_NOW, &extinfo);
171  ASSERT_TRUE(handle_ == nullptr);
172  ASSERT_SUBSTR("dlopen failed: file offset for the library \"libname_placeholder\" >= file size", dlerror());
173
174  extinfo.library_fd_offset = 0LL - PAGE_SIZE;
175  handle_ = android_dlopen_ext("libname_placeholder", RTLD_NOW, &extinfo);
176  ASSERT_TRUE(handle_ == nullptr);
177  ASSERT_SUBSTR("dlopen failed: file offset for the library \"libname_placeholder\" is negative", dlerror());
178
179  extinfo.library_fd_offset = 0;
180  handle_ = android_dlopen_ext("libname_ignored", RTLD_NOW, &extinfo);
181  ASSERT_TRUE(handle_ == nullptr);
182  ASSERT_EQ("dlopen failed: \"" + lib_realpath + "\" has bad ELF magic", dlerror());
183
184  // Check if dlsym works after unsuccessful dlopen().
185  // Supply non-exiting one to make linker visit every soinfo.
186  void* sym = dlsym(RTLD_DEFAULT, "this_symbol_does_not_exist___");
187  ASSERT_TRUE(sym == nullptr);
188
189  close(extinfo.library_fd);
190}
191
192TEST_F(DlExtTest, ExtInfoUseOffsetWithoutFd) {
193  android_dlextinfo extinfo;
194  extinfo.flags = ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET;
195  // This offset will not be used, so it doesn't matter.
196  extinfo.library_fd_offset = 0;
197
198  handle_ = android_dlopen_ext("/some/lib/that/does_not_exist", RTLD_NOW, &extinfo);
199  ASSERT_TRUE(handle_ == nullptr);
200  ASSERT_STREQ("dlopen failed: invalid extended flag combination (ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET without ANDROID_DLEXT_USE_LIBRARY_FD): 0x20", dlerror());
201}
202
203TEST(dlext, android_dlopen_ext_force_load_smoke) {
204  // 1. Open actual file
205  void* handle = dlopen("libdlext_test.so", RTLD_NOW);
206  ASSERT_DL_NOTNULL(handle);
207  // 2. Open link with force_load flag set
208  android_dlextinfo extinfo;
209  extinfo.flags = ANDROID_DLEXT_FORCE_LOAD;
210  void* handle2 = android_dlopen_ext("libdlext_test_v2.so", RTLD_NOW, &extinfo);
211  ASSERT_DL_NOTNULL(handle2);
212  ASSERT_TRUE(handle != handle2);
213
214  dlclose(handle2);
215  dlclose(handle);
216}
217
218TEST(dlext, android_dlopen_ext_force_load_soname_exception) {
219  // Check if soname lookup still returns already loaded library
220  // when ANDROID_DLEXT_FORCE_LOAD flag is specified.
221  void* handle = dlopen("libdlext_test_v2.so", RTLD_NOW);
222  ASSERT_DL_NOTNULL(handle);
223
224  android_dlextinfo extinfo;
225  extinfo.flags = ANDROID_DLEXT_FORCE_LOAD;
226
227  // Note that 'libdlext_test.so' is dt_soname for libdlext_test_v2.so
228  void* handle2 = android_dlopen_ext("libdlext_test.so", RTLD_NOW, &extinfo);
229
230  ASSERT_DL_NOTNULL(handle2);
231  ASSERT_TRUE(handle == handle2);
232
233  dlclose(handle2);
234  dlclose(handle);
235}
236
237TEST(dlfcn, dlopen_from_zip_absolute_path) {
238  const std::string lib_path = std::string(getenv("ANDROID_DATA")) + LIBZIPPATH;
239
240  void* handle = dlopen((lib_path + "!/libdir/libatest_simple_zip.so").c_str(), RTLD_NOW);
241  ASSERT_TRUE(handle != nullptr) << dlerror();
242
243  uint32_t* taxicab_number = reinterpret_cast<uint32_t*>(dlsym(handle, "dlopen_testlib_taxicab_number"));
244  ASSERT_DL_NOTNULL(taxicab_number);
245  EXPECT_EQ(1729U, *taxicab_number);
246
247  dlclose(handle);
248}
249
250TEST(dlfcn, dlopen_from_zip_with_dt_runpath) {
251  const std::string lib_path = std::string(getenv("ANDROID_DATA")) + LIBZIPPATH_WITH_RUNPATH;
252
253  void* handle = dlopen((lib_path + "!/libdir/libtest_dt_runpath_d_zip.so").c_str(), RTLD_NOW);
254
255  ASSERT_TRUE(handle != nullptr) << dlerror();
256
257  typedef void *(* dlopen_b_fn)();
258  dlopen_b_fn fn = (dlopen_b_fn)dlsym(handle, "dlopen_b");
259  ASSERT_TRUE(fn != nullptr) << dlerror();
260
261  void *p = fn();
262  ASSERT_TRUE(p != nullptr) << dlerror();
263
264  dlclose(p);
265  dlclose(handle);
266}
267
268TEST(dlfcn, dlopen_from_zip_ld_library_path) {
269  const std::string lib_path = std::string(getenv("ANDROID_DATA")) + LIBZIPPATH + "!/libdir";
270
271  typedef void (*fn_t)(const char*);
272  fn_t android_update_LD_LIBRARY_PATH =
273      reinterpret_cast<fn_t>(dlsym(RTLD_DEFAULT, "android_update_LD_LIBRARY_PATH"));
274
275  ASSERT_TRUE(android_update_LD_LIBRARY_PATH != nullptr) << dlerror();
276
277  void* handle = dlopen("libdlext_test_zip.so", RTLD_NOW);
278  ASSERT_TRUE(handle == nullptr);
279
280  android_update_LD_LIBRARY_PATH(lib_path.c_str());
281
282  handle = dlopen("libdlext_test_zip.so", RTLD_NOW);
283  ASSERT_TRUE(handle != nullptr) << dlerror();
284
285  int (*fn)(void);
286  fn = reinterpret_cast<int (*)(void)>(dlsym(handle, "getRandomNumber"));
287  ASSERT_TRUE(fn != nullptr);
288  EXPECT_EQ(4, fn());
289
290  uint32_t* taxicab_number =
291          reinterpret_cast<uint32_t*>(dlsym(handle, "dlopen_testlib_taxicab_number"));
292  ASSERT_DL_NOTNULL(taxicab_number);
293  EXPECT_EQ(1729U, *taxicab_number);
294
295  dlclose(handle);
296}
297
298
299TEST_F(DlExtTest, Reserved) {
300  void* start = mmap(nullptr, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
301  ASSERT_TRUE(start != MAP_FAILED);
302  android_dlextinfo extinfo;
303  extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS;
304  extinfo.reserved_addr = start;
305  extinfo.reserved_size = LIBSIZE;
306  handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
307  ASSERT_DL_NOTNULL(handle_);
308  fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
309  ASSERT_DL_NOTNULL(f);
310  EXPECT_GE(reinterpret_cast<void*>(f), start);
311  EXPECT_LT(reinterpret_cast<void*>(f),
312            reinterpret_cast<char*>(start) + LIBSIZE);
313  EXPECT_EQ(4, f());
314
315  // Check that after dlclose reserved address space is unmapped (and can be reused)
316  dlclose(handle_);
317  handle_ = nullptr;
318
319  void* new_start = mmap(start, PAGE_SIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
320  ASSERT_NE(start, new_start) << "dlclose unmapped reserved space";
321}
322
323TEST_F(DlExtTest, ReservedTooSmall) {
324  void* start = mmap(nullptr, PAGE_SIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
325  ASSERT_TRUE(start != MAP_FAILED);
326  android_dlextinfo extinfo;
327  extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS;
328  extinfo.reserved_addr = start;
329  extinfo.reserved_size = PAGE_SIZE;
330  handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
331  EXPECT_EQ(nullptr, handle_);
332}
333
334TEST_F(DlExtTest, ReservedHint) {
335  void* start = mmap(nullptr, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
336  ASSERT_TRUE(start != MAP_FAILED);
337  android_dlextinfo extinfo;
338  extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS_HINT;
339  extinfo.reserved_addr = start;
340  extinfo.reserved_size = LIBSIZE;
341  handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
342  ASSERT_DL_NOTNULL(handle_);
343  fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
344  ASSERT_DL_NOTNULL(f);
345  EXPECT_GE(reinterpret_cast<void*>(f), start);
346  EXPECT_LT(reinterpret_cast<void*>(f),
347            reinterpret_cast<char*>(start) + LIBSIZE);
348  EXPECT_EQ(4, f());
349}
350
351TEST_F(DlExtTest, ReservedHintTooSmall) {
352  void* start = mmap(nullptr, PAGE_SIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
353  ASSERT_TRUE(start != MAP_FAILED);
354  android_dlextinfo extinfo;
355  extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS_HINT;
356  extinfo.reserved_addr = start;
357  extinfo.reserved_size = PAGE_SIZE;
358  handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
359  ASSERT_DL_NOTNULL(handle_);
360  fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
361  ASSERT_DL_NOTNULL(f);
362  EXPECT_TRUE(reinterpret_cast<void*>(f) < start ||
363              (reinterpret_cast<void*>(f) >=
364               reinterpret_cast<char*>(start) + PAGE_SIZE));
365  EXPECT_EQ(4, f());
366}
367
368TEST_F(DlExtTest, LoadAtFixedAddress) {
369  void* start = mmap(nullptr, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
370  ASSERT_TRUE(start != MAP_FAILED);
371  munmap(start, LIBSIZE);
372
373  android_dlextinfo extinfo;
374  extinfo.flags = ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS;
375  extinfo.reserved_addr = start;
376
377  handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
378  ASSERT_DL_NOTNULL(handle_);
379  fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
380  ASSERT_DL_NOTNULL(f);
381  EXPECT_GE(reinterpret_cast<void*>(f), start);
382  EXPECT_LT(reinterpret_cast<void*>(f), reinterpret_cast<char*>(start) + LIBSIZE);
383
384  EXPECT_EQ(4, f());
385  dlclose(handle_);
386  handle_ = nullptr;
387
388  // Check that dlclose unmapped the file
389  void* addr = mmap(start, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
390  ASSERT_EQ(start, addr) << "dlclose did not unmap the memory";
391}
392
393TEST_F(DlExtTest, LoadAtFixedAddressTooSmall) {
394  void* start = mmap(nullptr, LIBSIZE + PAGE_SIZE, PROT_NONE,
395                         MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
396  ASSERT_TRUE(start != MAP_FAILED);
397  munmap(start, LIBSIZE + PAGE_SIZE);
398  void* new_addr = mmap(reinterpret_cast<uint8_t*>(start) + PAGE_SIZE, LIBSIZE, PROT_NONE,
399                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
400  ASSERT_TRUE(new_addr != MAP_FAILED);
401
402  android_dlextinfo extinfo;
403  extinfo.flags = ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS;
404  extinfo.reserved_addr = start;
405
406  handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
407  ASSERT_TRUE(handle_ == nullptr);
408}
409
410class DlExtRelroSharingTest : public DlExtTest {
411protected:
412  virtual void SetUp() {
413    DlExtTest::SetUp();
414    void* start = mmap(nullptr, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
415    ASSERT_TRUE(start != MAP_FAILED);
416    extinfo_.flags = ANDROID_DLEXT_RESERVED_ADDRESS;
417    extinfo_.reserved_addr = start;
418    extinfo_.reserved_size = LIBSIZE;
419    extinfo_.relro_fd = -1;
420  }
421
422  virtual void TearDown() {
423    DlExtTest::TearDown();
424  }
425
426  void CreateRelroFile(const char* lib, const char* relro_file) {
427    int relro_fd = open(relro_file, O_RDWR | O_TRUNC);
428    ASSERT_NOERROR(relro_fd);
429
430    pid_t pid = fork();
431    if (pid == 0) {
432      // child process
433      extinfo_.flags |= ANDROID_DLEXT_WRITE_RELRO;
434      extinfo_.relro_fd = relro_fd;
435      void* handle = android_dlopen_ext(lib, RTLD_NOW, &extinfo_);
436      if (handle == nullptr) {
437        fprintf(stderr, "in child: %s\n", dlerror());
438        exit(1);
439      }
440      exit(0);
441    }
442
443    // continuing in parent
444    ASSERT_NOERROR(close(relro_fd));
445    ASSERT_NOERROR(pid);
446    AssertChildExited(pid, 0);
447
448    // reopen file for reading so it can be used
449    relro_fd = open(relro_file, O_RDONLY);
450    ASSERT_NOERROR(relro_fd);
451    extinfo_.flags |= ANDROID_DLEXT_USE_RELRO;
452    extinfo_.relro_fd = relro_fd;
453  }
454
455  void TryUsingRelro(const char* lib) {
456    handle_ = android_dlopen_ext(lib, RTLD_NOW, &extinfo_);
457    ASSERT_DL_NOTNULL(handle_);
458    fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
459    ASSERT_DL_NOTNULL(f);
460    EXPECT_EQ(4, f());
461
462    uint32_t* taxicab_number =
463            reinterpret_cast<uint32_t*>(dlsym(handle_, "dlopen_testlib_taxicab_number"));
464    ASSERT_DL_NOTNULL(taxicab_number);
465    EXPECT_EQ(1729U, *taxicab_number);
466  }
467
468  void SpawnChildrenAndMeasurePss(const char* lib, bool share_relro, size_t* pss_out);
469
470  android_dlextinfo extinfo_;
471};
472
473TEST_F(DlExtRelroSharingTest, ChildWritesGoodData) {
474  TemporaryFile tf; // Use tf to get an unique filename.
475  ASSERT_NOERROR(close(tf.fd));
476
477  ASSERT_NO_FATAL_FAILURE(CreateRelroFile(LIBNAME, tf.filename));
478  ASSERT_NO_FATAL_FAILURE(TryUsingRelro(LIBNAME));
479
480  // Use destructor of tf to close and unlink the file.
481  tf.fd = extinfo_.relro_fd;
482}
483
484TEST_F(DlExtRelroSharingTest, ChildWritesNoRelro) {
485  TemporaryFile tf; // // Use tf to get an unique filename.
486  ASSERT_NOERROR(close(tf.fd));
487
488  ASSERT_NO_FATAL_FAILURE(CreateRelroFile(LIBNAME_NORELRO, tf.filename));
489  ASSERT_NO_FATAL_FAILURE(TryUsingRelro(LIBNAME_NORELRO));
490
491  // Use destructor of tf to close and unlink the file.
492  tf.fd = extinfo_.relro_fd;
493}
494
495TEST_F(DlExtRelroSharingTest, RelroFileEmpty) {
496  ASSERT_NO_FATAL_FAILURE(TryUsingRelro(LIBNAME));
497}
498
499TEST_F(DlExtRelroSharingTest, VerifyMemorySaving) {
500  if (geteuid() != 0) {
501    GTEST_LOG_(INFO) << "This test must be run as root.\n";
502    return;
503  }
504
505  TemporaryFile tf; // Use tf to get an unique filename.
506  ASSERT_NOERROR(close(tf.fd));
507
508  ASSERT_NO_FATAL_FAILURE(CreateRelroFile(LIBNAME, tf.filename));
509
510  int pipefd[2];
511  ASSERT_NOERROR(pipe(pipefd));
512
513  size_t without_sharing, with_sharing;
514  ASSERT_NO_FATAL_FAILURE(SpawnChildrenAndMeasurePss(LIBNAME, false, &without_sharing));
515  ASSERT_NO_FATAL_FAILURE(SpawnChildrenAndMeasurePss(LIBNAME, true, &with_sharing));
516
517  // We expect the sharing to save at least 10% of the total PSS. In practice
518  // it saves 40%+ for this test.
519  size_t expected_size = without_sharing - (without_sharing/10);
520  EXPECT_LT(with_sharing, expected_size);
521
522  // Use destructor of tf to close and unlink the file.
523  tf.fd = extinfo_.relro_fd;
524}
525
526void getPss(pid_t pid, size_t* pss_out) {
527  pm_kernel_t* kernel;
528  ASSERT_EQ(0, pm_kernel_create(&kernel));
529
530  pm_process_t* process;
531  ASSERT_EQ(0, pm_process_create(kernel, pid, &process));
532
533  pm_map_t** maps;
534  size_t num_maps;
535  ASSERT_EQ(0, pm_process_maps(process, &maps, &num_maps));
536
537  size_t total_pss = 0;
538  for (size_t i = 0; i < num_maps; i++) {
539    pm_memusage_t usage;
540    ASSERT_EQ(0, pm_map_usage(maps[i], &usage));
541    total_pss += usage.pss;
542  }
543  *pss_out = total_pss;
544
545  free(maps);
546  pm_process_destroy(process);
547  pm_kernel_destroy(kernel);
548}
549
550void DlExtRelroSharingTest::SpawnChildrenAndMeasurePss(const char* lib, bool share_relro,
551                                                       size_t* pss_out) {
552  const int CHILDREN = 20;
553
554  // Create children
555  pid_t child_pids[CHILDREN];
556  int childpipe[CHILDREN];
557  for (int i=0; i<CHILDREN; ++i) {
558    char read_buf;
559    int child_done_pipe[2], parent_done_pipe[2];
560    ASSERT_NOERROR(pipe(child_done_pipe));
561    ASSERT_NOERROR(pipe(parent_done_pipe));
562
563    pid_t child = fork();
564    if (child == 0) {
565      // close the 'wrong' ends of the pipes in the child
566      close(child_done_pipe[0]);
567      close(parent_done_pipe[1]);
568
569      // open the library
570      void* handle;
571      if (share_relro) {
572        handle = android_dlopen_ext(lib, RTLD_NOW, &extinfo_);
573      } else {
574        handle = dlopen(lib, RTLD_NOW);
575      }
576      if (handle == nullptr) {
577        fprintf(stderr, "in child: %s\n", dlerror());
578        exit(1);
579      }
580
581      // close write end of child_done_pipe to signal the parent that we're done.
582      close(child_done_pipe[1]);
583
584      // wait for the parent to close parent_done_pipe, then exit
585      read(parent_done_pipe[0], &read_buf, 1);
586      exit(0);
587    }
588
589    ASSERT_NOERROR(child);
590
591    // close the 'wrong' ends of the pipes in the parent
592    close(child_done_pipe[1]);
593    close(parent_done_pipe[0]);
594
595    // wait for the child to be done
596    read(child_done_pipe[0], &read_buf, 1);
597    close(child_done_pipe[0]);
598
599    // save the child's pid and the parent_done_pipe
600    child_pids[i] = child;
601    childpipe[i] = parent_done_pipe[1];
602  }
603
604  // Sum the PSS of all the children
605  size_t total_pss = 0;
606  for (int i=0; i<CHILDREN; ++i) {
607    size_t child_pss;
608    ASSERT_NO_FATAL_FAILURE(getPss(child_pids[i], &child_pss));
609    total_pss += child_pss;
610  }
611  *pss_out = total_pss;
612
613  // Close pipes and wait for children to exit
614  for (int i=0; i<CHILDREN; ++i) {
615    ASSERT_NOERROR(close(childpipe[i]));
616  }
617  for (int i = 0; i < CHILDREN; ++i) {
618    AssertChildExited(child_pids[i], 0);
619  }
620}
621
622// Testing namespaces
623static const char* g_public_lib = "libnstest_public.so";
624
625TEST(dlext, ns_smoke) {
626  static const char* root_lib = "libnstest_root.so";
627  std::string path = std::string("libc.so:libc++.so:libdl.so:libm.so:") + g_public_lib;
628
629  ASSERT_FALSE(android_init_namespaces(path.c_str(), nullptr));
630  ASSERT_STREQ("android_init_namespaces failed: error initializing public namespace: "
631               "\"libnstest_public.so\" was not found in the default namespace", dlerror());
632
633  const std::string lib_path = std::string(getenv("ANDROID_DATA")) + NATIVE_TESTS_PATH;
634
635  const std::string lib_public_path = lib_path + "/public_namespace_libs/" + g_public_lib;
636  void* handle_public = dlopen(lib_public_path.c_str(), RTLD_NOW);
637  ASSERT_TRUE(handle_public != nullptr) << dlerror();
638
639  ASSERT_TRUE(android_init_namespaces(path.c_str(), nullptr)) << dlerror();
640
641  // Check that libraries added to public namespace are NODELETE
642  dlclose(handle_public);
643  handle_public = dlopen((lib_path + "/public_namespace_libs/" + g_public_lib).c_str(),
644                         RTLD_NOW | RTLD_NOLOAD);
645
646  ASSERT_TRUE(handle_public != nullptr) << dlerror();
647
648  android_namespace_t* ns1 =
649          android_create_namespace("private", nullptr,
650                                   (lib_path + "/private_namespace_libs").c_str(),
651                                   ANDROID_NAMESPACE_TYPE_REGULAR, nullptr, nullptr);
652  ASSERT_TRUE(ns1 != nullptr) << dlerror();
653
654  android_namespace_t* ns2 =
655          android_create_namespace("private_isolated", nullptr,
656                                   (lib_path + "/private_namespace_libs").c_str(),
657                                   ANDROID_NAMESPACE_TYPE_ISOLATED, nullptr, nullptr);
658  ASSERT_TRUE(ns2 != nullptr) << dlerror();
659
660  // This should not have affect search path for default namespace:
661  ASSERT_TRUE(dlopen(root_lib, RTLD_NOW) == nullptr);
662  void* handle = dlopen(g_public_lib, RTLD_NOW);
663  ASSERT_TRUE(handle != nullptr) << dlerror();
664  dlclose(handle);
665
666  android_dlextinfo extinfo;
667  extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
668  extinfo.library_namespace = ns1;
669
670  void* handle1 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
671  ASSERT_TRUE(handle1 != nullptr) << dlerror();
672
673  extinfo.library_namespace = ns2;
674  void* handle2 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
675  ASSERT_TRUE(handle2 != nullptr) << dlerror();
676
677  ASSERT_TRUE(handle1 != handle2);
678
679  // dlopen for a public library using an absolute path should work for isolated namespaces
680  extinfo.library_namespace = ns2;
681  handle = android_dlopen_ext(lib_public_path.c_str(), RTLD_NOW, &extinfo);
682  ASSERT_TRUE(handle != nullptr) << dlerror();
683  ASSERT_TRUE(handle == handle_public);
684
685  dlclose(handle);
686
687  typedef const char* (*fn_t)();
688
689  fn_t ns_get_local_string1 = reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_local_string"));
690  ASSERT_TRUE(ns_get_local_string1 != nullptr) << dlerror();
691  fn_t ns_get_local_string2 = reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_local_string"));
692  ASSERT_TRUE(ns_get_local_string2 != nullptr) << dlerror();
693
694  EXPECT_STREQ("This string is local to root library", ns_get_local_string1());
695  EXPECT_STREQ("This string is local to root library", ns_get_local_string2());
696
697  ASSERT_TRUE(ns_get_local_string1() != ns_get_local_string2());
698
699  fn_t ns_get_private_extern_string1 =
700          reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_private_extern_string"));
701  ASSERT_TRUE(ns_get_private_extern_string1 != nullptr) << dlerror();
702  fn_t ns_get_private_extern_string2 =
703          reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_private_extern_string"));
704  ASSERT_TRUE(ns_get_private_extern_string2 != nullptr) << dlerror();
705
706  EXPECT_STREQ("This string is from private namespace", ns_get_private_extern_string1());
707  EXPECT_STREQ("This string is from private namespace", ns_get_private_extern_string2());
708
709  ASSERT_TRUE(ns_get_private_extern_string1() != ns_get_private_extern_string2());
710
711  fn_t ns_get_public_extern_string1 =
712          reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_public_extern_string"));
713  ASSERT_TRUE(ns_get_public_extern_string1 != nullptr) << dlerror();
714  fn_t ns_get_public_extern_string2 =
715          reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_public_extern_string"));
716  ASSERT_TRUE(ns_get_public_extern_string2 != nullptr) << dlerror();
717
718  EXPECT_STREQ("This string is from public namespace", ns_get_public_extern_string1());
719  ASSERT_TRUE(ns_get_public_extern_string1() == ns_get_public_extern_string2());
720
721  // and now check that dlopen() does the right thing in terms of preserving namespace
722  fn_t ns_get_dlopened_string1 = reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_dlopened_string"));
723  ASSERT_TRUE(ns_get_dlopened_string1 != nullptr) << dlerror();
724  fn_t ns_get_dlopened_string2 = reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_dlopened_string"));
725  ASSERT_TRUE(ns_get_dlopened_string2 != nullptr) << dlerror();
726
727  EXPECT_STREQ("This string is from private namespace (dlopened library)", ns_get_dlopened_string1());
728  EXPECT_STREQ("This string is from private namespace (dlopened library)", ns_get_dlopened_string2());
729
730  ASSERT_TRUE(ns_get_dlopened_string1() != ns_get_dlopened_string2());
731
732  dlclose(handle1);
733
734  // Check if handle2 is still alive (and well)
735  ASSERT_STREQ("This string is local to root library", ns_get_local_string2());
736  ASSERT_STREQ("This string is from private namespace", ns_get_private_extern_string2());
737  ASSERT_STREQ("This string is from public namespace", ns_get_public_extern_string2());
738  ASSERT_STREQ("This string is from private namespace (dlopened library)", ns_get_dlopened_string2());
739
740  dlclose(handle2);
741}
742
743TEST(dlext, ns_isolated) {
744  static const char* root_lib = "libnstest_root_not_isolated.so";
745  std::string path = std::string("libc.so:libc++.so:libdl.so:libm.so:") + g_public_lib;
746
747  const std::string lib_path = std::string(getenv("ANDROID_DATA")) + NATIVE_TESTS_PATH;
748  const std::string lib_public_path = lib_path + "/public_namespace_libs/" + g_public_lib;
749  void* handle_public = dlopen(lib_public_path.c_str(), RTLD_NOW);
750  ASSERT_TRUE(handle_public != nullptr) << dlerror();
751
752  android_set_application_target_sdk_version(42U); // something > 23
753
754  ASSERT_TRUE(android_init_namespaces(path.c_str(), nullptr)) << dlerror();
755
756  android_namespace_t* ns_not_isolated =
757          android_create_namespace("private", nullptr,
758                                   (lib_path + "/private_namespace_libs").c_str(),
759                                   ANDROID_NAMESPACE_TYPE_REGULAR, nullptr, nullptr);
760  ASSERT_TRUE(ns_not_isolated != nullptr) << dlerror();
761
762  android_namespace_t* ns_isolated =
763          android_create_namespace("private_isolated1",
764                                   nullptr,
765                                   (lib_path + "/private_namespace_libs").c_str(),
766                                   ANDROID_NAMESPACE_TYPE_ISOLATED,
767                                   nullptr,
768                                   nullptr);
769  ASSERT_TRUE(ns_isolated != nullptr) << dlerror();
770
771  android_namespace_t* ns_isolated2 =
772          android_create_namespace("private_isolated2",
773                                   (lib_path + "/private_namespace_libs").c_str(),
774                                   nullptr,
775                                   ANDROID_NAMESPACE_TYPE_ISOLATED,
776                                   lib_path.c_str(),
777                                   nullptr);
778  ASSERT_TRUE(ns_isolated2 != nullptr) << dlerror();
779
780  ASSERT_TRUE(dlopen(root_lib, RTLD_NOW) == nullptr);
781  ASSERT_STREQ("dlopen failed: library \"libnstest_root_not_isolated.so\" not found", dlerror());
782
783  std::string lib_private_external_path =
784      lib_path + "/private_namespace_libs_external/libnstest_private_external.so";
785
786  // Load lib_private_external_path to default namespace
787  // (it should remain invisible for the isolated namespaces after this)
788  void* handle = dlopen(lib_private_external_path.c_str(), RTLD_NOW);
789  ASSERT_TRUE(handle != nullptr) << dlerror();
790
791  android_dlextinfo extinfo;
792  extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
793  extinfo.library_namespace = ns_not_isolated;
794
795  void* handle1 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
796  ASSERT_TRUE(handle1 != nullptr) << dlerror();
797
798  extinfo.library_namespace = ns_isolated;
799
800  void* handle2 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
801  ASSERT_TRUE(handle2 == nullptr);
802  ASSERT_STREQ("dlopen failed: library \"libnstest_private_external.so\" not found", dlerror());
803
804  // Check dlopen by absolute path
805  handle2 = android_dlopen_ext(lib_private_external_path.c_str(), RTLD_NOW, &extinfo);
806  ASSERT_TRUE(handle2 == nullptr);
807  ASSERT_EQ("dlopen failed: library \"" + lib_private_external_path + "\" needed"
808            " or dlopened by \"" + get_executable_path() +  "\" is not accessible"
809            " for the namespace \"private_isolated1\"", dlerror());
810
811  extinfo.library_namespace = ns_isolated2;
812
813  // this should work because isolation_path for private_isolated2 includes lib_path
814  handle2 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
815  ASSERT_TRUE(handle2 != nullptr) << dlerror();
816  dlclose(handle2);
817
818  // Check dlopen by absolute path
819  handle2 = android_dlopen_ext(lib_private_external_path.c_str(), RTLD_NOW, &extinfo);
820  ASSERT_TRUE(handle2 != nullptr) << dlerror();
821  dlclose(handle2);
822
823  typedef const char* (*fn_t)();
824  fn_t ns_get_local_string = reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_local_string"));
825  ASSERT_TRUE(ns_get_local_string != nullptr) << dlerror();
826
827  ASSERT_STREQ("This string is local to root library", ns_get_local_string());
828
829  fn_t ns_get_private_extern_string =
830          reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_private_extern_string"));
831  ASSERT_TRUE(ns_get_private_extern_string != nullptr) << dlerror();
832
833  ASSERT_STREQ("This string is from private namespace", ns_get_private_extern_string());
834
835  fn_t ns_get_public_extern_string =
836          reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_public_extern_string"));
837  ASSERT_TRUE(ns_get_public_extern_string != nullptr) << dlerror();
838
839  ASSERT_STREQ("This string is from public namespace", ns_get_public_extern_string());
840
841  fn_t ns_get_dlopened_string = reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_dlopened_string"));
842  ASSERT_TRUE(ns_get_dlopened_string != nullptr) << dlerror();
843
844  ASSERT_STREQ("This string is from private namespace (dlopened library)", ns_get_dlopened_string());
845
846  dlclose(handle1);
847}
848
849TEST(dlext, ns_shared) {
850  static const char* root_lib = "libnstest_root_not_isolated.so";
851  static const char* root_lib_isolated = "libnstest_root.so";
852  std::string path = std::string("libc.so:libc++.so:libdl.so:libm.so:") + g_public_lib;
853
854  const std::string lib_path = std::string(getenv("ANDROID_DATA")) + NATIVE_TESTS_PATH;
855  const std::string lib_public_path = lib_path + "/public_namespace_libs/" + g_public_lib;
856  void* handle_public = dlopen(lib_public_path.c_str(), RTLD_NOW);
857  ASSERT_TRUE(handle_public != nullptr) << dlerror();
858
859  android_set_application_target_sdk_version(42U); // something > 23
860
861  ASSERT_TRUE(android_init_namespaces(path.c_str(), nullptr)) << dlerror();
862
863  // preload this library to the default namespace to check if it
864  // is shared later on.
865  void* handle_dlopened =
866          dlopen((lib_path + "/private_namespace_libs/libnstest_dlopened.so").c_str(), RTLD_NOW);
867  ASSERT_TRUE(handle_dlopened != nullptr) << dlerror();
868
869  android_namespace_t* ns_not_isolated =
870          android_create_namespace("private", nullptr,
871                                   (lib_path + "/private_namespace_libs").c_str(),
872                                   ANDROID_NAMESPACE_TYPE_REGULAR, nullptr, nullptr);
873  ASSERT_TRUE(ns_not_isolated != nullptr) << dlerror();
874
875  android_namespace_t* ns_isolated_shared =
876          android_create_namespace("private_isolated_shared", nullptr,
877                                   (lib_path + "/private_namespace_libs").c_str(),
878                                   ANDROID_NAMESPACE_TYPE_ISOLATED | ANDROID_NAMESPACE_TYPE_SHARED,
879                                   nullptr, nullptr);
880  ASSERT_TRUE(ns_isolated_shared != nullptr) << dlerror();
881
882  ASSERT_TRUE(dlopen(root_lib, RTLD_NOW) == nullptr);
883  ASSERT_STREQ("dlopen failed: library \"libnstest_root_not_isolated.so\" not found", dlerror());
884
885  std::string lib_private_external_path =
886      lib_path + "/private_namespace_libs_external/libnstest_private_external.so";
887
888  // Load lib_private_external_path to default namespace
889  // (it should remain invisible for the isolated namespaces after this)
890  void* handle = dlopen(lib_private_external_path.c_str(), RTLD_NOW);
891  ASSERT_TRUE(handle != nullptr) << dlerror();
892
893  android_dlextinfo extinfo;
894  extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
895  extinfo.library_namespace = ns_not_isolated;
896
897  void* handle1 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
898  ASSERT_TRUE(handle1 != nullptr) << dlerror();
899
900  extinfo.library_namespace = ns_isolated_shared;
901
902  void* handle2 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
903  ASSERT_TRUE(handle2 == nullptr);
904  ASSERT_STREQ("dlopen failed: library \"libnstest_private_external.so\" not found", dlerror());
905
906  // Check dlopen by absolute path
907  handle2 = android_dlopen_ext(lib_private_external_path.c_str(), RTLD_NOW, &extinfo);
908  ASSERT_TRUE(handle2 == nullptr);
909  ASSERT_EQ("dlopen failed: library \"" + lib_private_external_path + "\" needed"
910            " or dlopened by \"" + get_executable_path() + "\" is not accessible"
911            " for the namespace \"private_isolated_shared\"", dlerror());
912
913  // load libnstest_root.so to shared namespace in order to check that everything is different
914  // except shared libnstest_dlopened.so
915
916  handle2 = android_dlopen_ext(root_lib_isolated, RTLD_NOW, &extinfo);
917
918  typedef const char* (*fn_t)();
919  fn_t ns_get_local_string = reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_local_string"));
920  ASSERT_TRUE(ns_get_local_string != nullptr) << dlerror();
921  fn_t ns_get_local_string_shared = reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_local_string"));
922  ASSERT_TRUE(ns_get_local_string_shared != nullptr) << dlerror();
923
924  ASSERT_STREQ("This string is local to root library", ns_get_local_string());
925  ASSERT_STREQ("This string is local to root library", ns_get_local_string_shared());
926  ASSERT_TRUE(ns_get_local_string() != ns_get_local_string_shared());
927
928  fn_t ns_get_private_extern_string =
929          reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_private_extern_string"));
930  ASSERT_TRUE(ns_get_private_extern_string != nullptr) << dlerror();
931  fn_t ns_get_private_extern_string_shared =
932          reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_private_extern_string"));
933  ASSERT_TRUE(ns_get_private_extern_string_shared() != nullptr) << dlerror();
934
935  ASSERT_STREQ("This string is from private namespace", ns_get_private_extern_string());
936  ASSERT_STREQ("This string is from private namespace", ns_get_private_extern_string_shared());
937  ASSERT_TRUE(ns_get_private_extern_string() != ns_get_private_extern_string_shared());
938
939  fn_t ns_get_public_extern_string =
940          reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_public_extern_string"));
941  ASSERT_TRUE(ns_get_public_extern_string != nullptr) << dlerror();
942  fn_t ns_get_public_extern_string_shared =
943          reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_public_extern_string"));
944  ASSERT_TRUE(ns_get_public_extern_string_shared != nullptr) << dlerror();
945
946  ASSERT_STREQ("This string is from public namespace", ns_get_public_extern_string());
947  ASSERT_STREQ("This string is from public namespace", ns_get_public_extern_string_shared());
948  ASSERT_TRUE(ns_get_public_extern_string() == ns_get_public_extern_string_shared());
949
950  fn_t ns_get_dlopened_string = reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_dlopened_string"));
951  ASSERT_TRUE(ns_get_dlopened_string != nullptr) << dlerror();
952  fn_t ns_get_dlopened_string_shared = reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_dlopened_string"));
953  ASSERT_TRUE(ns_get_dlopened_string_shared != nullptr) << dlerror();
954  const char** ns_dlopened_string = static_cast<const char**>(dlsym(handle_dlopened, "g_private_dlopened_string"));
955  ASSERT_TRUE(ns_dlopened_string != nullptr) << dlerror();
956
957  ASSERT_STREQ("This string is from private namespace (dlopened library)", ns_get_dlopened_string());
958  ASSERT_STREQ("This string is from private namespace (dlopened library)", *ns_dlopened_string);
959  ASSERT_STREQ("This string is from private namespace (dlopened library)", ns_get_dlopened_string_shared());
960  ASSERT_TRUE(ns_get_dlopened_string() != ns_get_dlopened_string_shared());
961  ASSERT_TRUE(*ns_dlopened_string == ns_get_dlopened_string_shared());
962
963  dlclose(handle1);
964  dlclose(handle2);
965}
966
967TEST(dlext, ns_shared_dlclose) {
968  std::string path = "libc.so:libc++.so:libdl.so:libm.so";
969
970  const std::string lib_path = std::string(getenv("ANDROID_DATA")) + NATIVE_TESTS_PATH;
971
972  android_set_application_target_sdk_version(42U); // something > 23
973
974  ASSERT_TRUE(android_init_namespaces(path.c_str(), nullptr)) << dlerror();
975
976  // preload this library to the default namespace to check if it
977  // is shared later on.
978  void* handle_dlopened =
979          dlopen((lib_path + "/private_namespace_libs/libnstest_dlopened.so").c_str(), RTLD_NOW);
980  ASSERT_TRUE(handle_dlopened != nullptr) << dlerror();
981
982  android_namespace_t* ns_isolated_shared =
983          android_create_namespace("private_isolated_shared", nullptr,
984                                   (lib_path + "/private_namespace_libs").c_str(),
985                                   ANDROID_NAMESPACE_TYPE_ISOLATED | ANDROID_NAMESPACE_TYPE_SHARED,
986                                   nullptr, nullptr);
987  ASSERT_TRUE(ns_isolated_shared != nullptr) << dlerror();
988
989  // Check if "libnstest_dlopened.so" is loaded (and the same)
990  android_dlextinfo extinfo;
991  extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
992  extinfo.library_namespace = ns_isolated_shared;
993
994  void* handle = android_dlopen_ext("libnstest_dlopened.so", RTLD_NOW | RTLD_NOLOAD, &extinfo);
995  ASSERT_TRUE(handle != nullptr) << dlerror();
996  ASSERT_TRUE(handle == handle_dlopened);
997  dlclose(handle);
998  dlclose(handle_dlopened);
999
1000  // And now check that the library cannot be found by soname (and is no longer loaded)
1001  handle = android_dlopen_ext("libnstest_dlopened.so", RTLD_NOW | RTLD_NOLOAD, &extinfo);
1002  ASSERT_TRUE(handle == nullptr)
1003      << "Error: libnstest_dlopened.so is still accessible in shared namespace";
1004
1005  handle = android_dlopen_ext((lib_path + "/private_namespace_libs/libnstest_dlopened.so").c_str(),
1006                              RTLD_NOW | RTLD_NOLOAD, &extinfo);
1007  ASSERT_TRUE(handle == nullptr)
1008      << "Error: libnstest_dlopened.so is still accessible in shared namespace";
1009
1010  handle = dlopen("libnstest_dlopened.so", RTLD_NOW | RTLD_NOLOAD);
1011  ASSERT_TRUE(handle == nullptr)
1012      << "Error: libnstest_dlopened.so is still accessible in default namespace";
1013
1014  handle = dlopen((lib_path + "/private_namespace_libs/libnstest_dlopened.so").c_str(),
1015                  RTLD_NOW | RTLD_NOLOAD);
1016  ASSERT_TRUE(handle == nullptr)
1017      << "Error: libnstest_dlopened.so is still accessible in default namespace";
1018
1019  // Now lets see if the soinfo area gets reused in the wrong way:
1020  // load a library to default namespace.
1021  const std::string lib_public_path = lib_path + "/public_namespace_libs/" + g_public_lib;
1022  void* handle_public = dlopen(lib_public_path.c_str(), RTLD_NOW);
1023  ASSERT_TRUE(handle_public != nullptr) << dlerror();
1024
1025  // try to find it in shared namespace
1026  handle = android_dlopen_ext(g_public_lib, RTLD_NOW | RTLD_NOLOAD, &extinfo);
1027  ASSERT_TRUE(handle == nullptr)
1028      << "Error: " << g_public_lib << " is accessible in shared namespace";
1029}
1030
1031TEST(dlext, ns_isolated_rtld_global) {
1032  static const char* root_lib = "libnstest_root.so";
1033  std::string path = "libc.so:libc++.so:libdl.so:libm.so";
1034
1035  ASSERT_TRUE(android_init_namespaces(path.c_str(), nullptr));
1036
1037  const std::string lib_path = std::string(getenv("ANDROID_DATA")) + NATIVE_TESTS_PATH;
1038
1039  const std::string lib_public_path = lib_path + "/public_namespace_libs";
1040
1041  android_namespace_t* ns1 =
1042          android_create_namespace("isolated1",
1043                                   nullptr,
1044                                   (lib_path + "/private_namespace_libs").c_str(),
1045                                   ANDROID_NAMESPACE_TYPE_ISOLATED,
1046                                   lib_public_path.c_str(),
1047                                   nullptr);
1048  ASSERT_TRUE(ns1 != nullptr) << dlerror();
1049
1050  android_namespace_t* ns2 =
1051          android_create_namespace("isolated2",
1052                                   nullptr,
1053                                   (lib_path + "/private_namespace_libs").c_str(),
1054                                   ANDROID_NAMESPACE_TYPE_ISOLATED,
1055                                   lib_public_path.c_str(),
1056                                   nullptr);
1057  ASSERT_TRUE(ns2 != nullptr) << dlerror();
1058
1059  android_dlextinfo extinfo;
1060  extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
1061  extinfo.library_namespace = ns1;
1062
1063  void* handle_global = android_dlopen_ext((lib_public_path + "/" + g_public_lib).c_str(),
1064                                           RTLD_GLOBAL,
1065                                           &extinfo);
1066
1067  ASSERT_TRUE(handle_global != nullptr) << dlerror();
1068
1069  android_namespace_t* ns1_child =
1070        android_create_namespace("isolated1_child",
1071                                 nullptr,
1072                                 (lib_path + "/private_namespace_libs").c_str(),
1073                                 ANDROID_NAMESPACE_TYPE_ISOLATED,
1074                                 nullptr,
1075                                 ns1);
1076
1077  // Now - only ns1 and ns1 child should be able to dlopen root_lib
1078  // attempt to use ns2 should result in dlerror()
1079
1080  // Check ns1_child first.
1081  extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
1082  extinfo.library_namespace = ns1_child;
1083
1084  void* handle1 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
1085  ASSERT_TRUE(handle1 != nullptr) << dlerror();
1086
1087  // now ns1
1088  extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
1089  extinfo.library_namespace = ns1;
1090
1091  handle1 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
1092  ASSERT_TRUE(handle1 != nullptr) << dlerror();
1093
1094  // and ns2 should fail
1095  extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
1096  extinfo.library_namespace = ns2;
1097
1098  handle1 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
1099  ASSERT_TRUE(handle1 == nullptr);
1100  ASSERT_STREQ("dlopen failed: library \"libnstest_public.so\" not found", dlerror());
1101}
1102
1103TEST(dlext, ns_anonymous) {
1104  static const char* root_lib = "libnstest_root.so";
1105  std::string path = std::string("libc.so:libc++.so:libdl.so:libm.so:") + g_public_lib;
1106
1107  const std::string lib_path = std::string(getenv("ANDROID_DATA")) + NATIVE_TESTS_PATH;
1108
1109  const std::string lib_public_path = lib_path + "/public_namespace_libs/" + g_public_lib;
1110  void* handle_public = dlopen(lib_public_path.c_str(), RTLD_NOW);
1111
1112  ASSERT_TRUE(handle_public != nullptr) << dlerror();
1113
1114  ASSERT_TRUE(android_init_namespaces(path.c_str(), (lib_path + "/private_namespace_libs").c_str()))
1115      << dlerror();
1116
1117  android_namespace_t* ns = android_create_namespace(
1118                                "private", nullptr,
1119                                (lib_path + "/private_namespace_libs").c_str(),
1120                                ANDROID_NAMESPACE_TYPE_REGULAR, nullptr, nullptr);
1121
1122  ASSERT_TRUE(ns != nullptr) << dlerror();
1123
1124  std::string private_library_absolute_path = lib_path + "/private_namespace_libs/" + root_lib;
1125
1126  android_dlextinfo extinfo;
1127  extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
1128  extinfo.library_namespace = ns;
1129
1130  // we are going to copy this library to anonymous mmap and call the copy of ns_get_dlopened_string
1131  void* handle = android_dlopen_ext(private_library_absolute_path.c_str(), RTLD_NOW, &extinfo);
1132  ASSERT_TRUE(handle != nullptr) << dlerror();
1133
1134  uintptr_t ns_get_dlopened_string_addr =
1135      reinterpret_cast<uintptr_t>(dlsym(handle, "ns_get_dlopened_string"));
1136  ASSERT_TRUE(ns_get_dlopened_string_addr != 0) << dlerror();
1137  typedef const char* (*fn_t)();
1138  fn_t ns_get_dlopened_string_private = reinterpret_cast<fn_t>(ns_get_dlopened_string_addr);
1139
1140  std::vector<map_record> maps;
1141  Maps::parse_maps(&maps);
1142
1143  uintptr_t addr_start = 0;
1144  uintptr_t addr_end = 0;
1145  std::vector<map_record> maps_to_copy;
1146
1147  for (const auto& rec : maps) {
1148    if (rec.pathname == private_library_absolute_path) {
1149      if (addr_start == 0) {
1150        addr_start = rec.addr_start;
1151      }
1152      addr_end = rec.addr_end;
1153
1154      maps_to_copy.push_back(rec);
1155    }
1156  }
1157
1158  // some sanity checks..
1159  ASSERT_TRUE(addr_start > 0);
1160  ASSERT_TRUE(addr_end > 0);
1161  ASSERT_EQ(3U, maps_to_copy.size());
1162  ASSERT_TRUE(ns_get_dlopened_string_addr > addr_start);
1163  ASSERT_TRUE(ns_get_dlopened_string_addr < addr_end);
1164
1165  // copy
1166  uintptr_t reserved_addr = reinterpret_cast<uintptr_t>(mmap(nullptr, addr_end - addr_start,
1167                                                             PROT_NONE, MAP_ANON | MAP_PRIVATE,
1168                                                             -1, 0));
1169  ASSERT_TRUE(reinterpret_cast<void*>(reserved_addr) != MAP_FAILED);
1170
1171  for (const auto& rec : maps_to_copy) {
1172    uintptr_t offset = rec.addr_start - addr_start;
1173    size_t size = rec.addr_end - rec.addr_start;
1174    void* addr = reinterpret_cast<void*>(reserved_addr + offset);
1175    void* map = mmap(addr, size, PROT_READ | PROT_WRITE,
1176                     MAP_ANON | MAP_PRIVATE | MAP_FIXED, -1, 0);
1177    ASSERT_TRUE(map != MAP_FAILED);
1178    memcpy(map, reinterpret_cast<void*>(rec.addr_start), size);
1179    mprotect(map, size, rec.perms);
1180  }
1181
1182  // call the function copy
1183  uintptr_t ns_get_dlopened_string_offset  = ns_get_dlopened_string_addr - addr_start;
1184  fn_t ns_get_dlopened_string_anon = reinterpret_cast<fn_t>(reserved_addr + ns_get_dlopened_string_offset);
1185  ASSERT_STREQ("This string is from private namespace (dlopened library)",
1186               ns_get_dlopened_string_anon());
1187
1188  // They should belong to different namespaces (private and anonymous)
1189  ASSERT_STREQ("This string is from private namespace (dlopened library)",
1190               ns_get_dlopened_string_private());
1191
1192  ASSERT_TRUE(ns_get_dlopened_string_anon() != ns_get_dlopened_string_private());
1193}
1194
1195TEST(dlext, dlopen_handle_value_platform) {
1196  void* handle = dlopen("libtest_dlsym_from_this.so", RTLD_NOW | RTLD_LOCAL);
1197  ASSERT_TRUE((reinterpret_cast<uintptr_t>(handle) & 1) != 0)
1198          << "dlopen should return odd value for the handle";
1199  dlclose(handle);
1200}
1201
1202TEST(dlext, dlopen_handle_value_app_compat) {
1203  android_set_application_target_sdk_version(23);
1204  void* handle = dlopen("libtest_dlsym_from_this.so", RTLD_NOW | RTLD_LOCAL);
1205  ASSERT_TRUE(reinterpret_cast<uintptr_t>(handle) % sizeof(uintptr_t) == 0)
1206          << "dlopen should return valid pointer";
1207  dlclose(handle);
1208}
1209
1210