#include <dlfcn.h>

#include <errno.h>

#include <fcntl.h>

#include <inttypes.h>

#include <pthread.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <unistd.h>

#include "private/bionic_tls.h"

#include "private/KernelArgumentBlock.h"

#include "private/ScopedPthreadMutexLocker.h"

#include "private/ScopedFd.h"

#include "linker.h"

#include "linker_debug.h"

#include "linker_environ.h"

#include "linker_phdr.h"

#include "linker_allocator.h"

#if defined(__LP64__)

#define SEARCH_NAME(x) x

#else

static const char* get_base_name(const char* name) {

const char* bname = strrchr(name, '/');

return bname ? bname + 1 : name;

}

#define SEARCH_NAME(x) get_base_name(x)

#endif

static bool soinfo_link_image(soinfo* si, const android_dlextinfo* extinfo);

static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf);

static LinkerAllocator<soinfo> g_soinfo_allocator;

static LinkerAllocator<LinkedListEntry<soinfo>> g_soinfo_links_allocator;

static soinfo* solist;

static soinfo* sonext;

static soinfo* somain; /* main process, always the one after libdl_info */

static const char* const kDefaultLdPaths[] = {

#if defined(__LP64__)

"/vendor/lib64",

"/system/lib64",

#else

"/vendor/lib",

"/system/lib",

#endif

NULL

};

#define LDPATH_BUFSIZE (LDPATH_MAX*64)

#define LDPATH_MAX 8

#define LDPRELOAD_BUFSIZE (LDPRELOAD_MAX*64)

#define LDPRELOAD_MAX 8

static char g_ld_library_paths_buffer[LDPATH_BUFSIZE];

static const char* g_ld_library_paths[LDPATH_MAX + 1];

static char g_ld_preloads_buffer[LDPRELOAD_BUFSIZE];

static const char* g_ld_preload_names[LDPRELOAD_MAX + 1];

static soinfo* g_ld_preloads[LDPRELOAD_MAX + 1];

__LIBC_HIDDEN__ int g_ld_debug_verbosity;

__LIBC_HIDDEN__ abort_msg_t* g_abort_message = NULL; // For debuggerd.

enum RelocationKind {

};

#if STATS

struct linker_stats_t {

int count[kRelocMax];

};

static linker_stats_t linker_stats;

static void count_relocation(RelocationKind kind) {

++linker_stats.count[kind];

}

#else

static void count_relocation(RelocationKind) {

}

#endif

#if COUNT_PAGES

static unsigned bitmask[4096];

#if defined(__LP64__)

#define MARK(offset) \

do { \

if ((((offset) >> 12) >> 5) < 4096) \

bitmask[((offset) >> 12) >> 5] |= (1 << (((offset) >> 12) & 31)); \

} while (0)

#else

#define MARK(offset) \

do { \

bitmask[((offset) >> 12) >> 3] |= (1 << (((offset) >> 12) & 7)); \

} while (0)

#endif

#else

#define MARK(x) do {} while (0)

#endif

#define DISALLOW_ALLOCATION(return_type, name, ...) \

return_type name __VA_ARGS__ \

{ \

__libc_fatal("ERROR: " #name " called from the dynamic linker!\n"); \

}

DISALLOW_ALLOCATION(void*, malloc, (size_t u __unused));

DISALLOW_ALLOCATION(void, free, (void* u __unused));

DISALLOW_ALLOCATION(void*, realloc, (void* u1 __unused, size_t u2 __unused));

DISALLOW_ALLOCATION(void*, calloc, (size_t u1 __unused, size_t u2 __unused));

static char tmp_err_buf[768];

static char __linker_dl_err_buf[768];

char* linker_get_error_buffer() {

return &__linker_dl_err_buf[0];

}

size_t linker_get_error_buffer_size() {

return sizeof(__linker_dl_err_buf);

}

extern "C" void __attribute__((noinline)) __attribute__((visibility("default"))) rtld_db_dlactivity();

static pthread_mutex_t g__r_debug_mutex = PTHREAD_MUTEX_INITIALIZER;

static r_debug _r_debug = {1, NULL, reinterpret_cast<uintptr_t>(&rtld_db_dlactivity), r_debug::RT_CONSISTENT, 0};

static link_map* r_debug_tail = 0;

static void insert_soinfo_into_debug_map(soinfo* info) {

}

static void remove_soinfo_from_debug_map(soinfo* info) {

}

static void notify_gdb_of_load(soinfo* info) {

}

static void notify_gdb_of_unload(soinfo* info) {

}

void notify_gdb_of_libraries() {

}

LinkedListEntry<soinfo>* SoinfoListAllocator::alloc() {

return g_soinfo_links_allocator.alloc();

}

void SoinfoListAllocator::free(LinkedListEntry<soinfo>* entry) {

g_soinfo_links_allocator.free(entry);

}

static void protect_data(int protection) {

g_soinfo_allocator.protect_all(protection);

g_soinfo_links_allocator.protect_all(protection);

}

static soinfo* soinfo_alloc(const char* name, struct stat* file_stat) {

if (strlen(name) >= SOINFO_NAME_LEN) {

DL_ERR("library name \"%s\" too long", name);

return NULL;

}

soinfo* si = g_soinfo_allocator.alloc();

// Initialize the new element.

memset(si, 0, sizeof(soinfo));

strlcpy(si->name, name, sizeof(si->name));

si->flags = FLAG_NEW_SOINFO;

if (file_stat != NULL) {

si->set_st_dev(file_stat->st_dev);

si->set_st_ino(file_stat->st_ino);

}

sonext->next = si;

sonext = si;

TRACE("name %s: allocated soinfo @ %p", name, si);

return si;

}

static void soinfo_free(soinfo* si) {

}

static void parse_path(const char* path, const char* delimiters,

}

static void parse_LD_LIBRARY_PATH(const char* path) {

parse_path(path, ":", g_ld_library_paths,

g_ld_library_paths_buffer, sizeof(g_ld_library_paths_buffer), LDPATH_MAX);

}

static void parse_LD_PRELOAD(const char* path) {

}

#if defined(__arm__)

_Unwind_Ptr dl_unwind_find_exidx(_Unwind_Ptr pc, int* pcount) {

}

#endif

int dl_iterate_phdr(int (*cb)(dl_phdr_info* info, size_t size, void* data), void* data) {

}

static ElfW(Sym)* soinfo_elf_lookup(soinfo* si, unsigned hash, const char* name) {

ElfW(Sym)* symtab = si->symtab;

const char* strtab = si->strtab;

TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p %x %zd",

name, si->name, reinterpret_cast<void*>(si->base), hash, hash % si->nbucket);

for (unsigned n = si->bucket[hash % si->nbucket]; n != 0; n = si->chain[n]) {

ElfW(Sym)* s = symtab + n;

if (strcmp(strtab + s->st_name, name)) continue;

/* only concern ourselves with global and weak symbol definitions */

switch (ELF_ST_BIND(s->st_info)) {

case STB_GLOBAL:

case STB_WEAK:

if (s->st_shndx == SHN_UNDEF) {

continue;

}

TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",

name, si->name, reinterpret_cast<void*>(s->st_value),

static_cast<size_t>(s->st_size));

return s;

case STB_LOCAL:

continue;

default:

__libc_fatal("ERROR: Unexpected ST_BIND value: %d for '%s' in '%s'",

ELF_ST_BIND(s->st_info), name, si->name);

}

}

TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p %x %zd",

name, si->name, reinterpret_cast<void*>(si->base), hash, hash % si->nbucket);

return NULL;

}

static unsigned elfhash(const char* _name) {

}

static ElfW(Sym)* soinfo_do_lookup(soinfo* si, const char* name, soinfo** lsi, soinfo* needed[]) {

unsigned elf_hash = elfhash(name);

ElfW(Sym)* s = NULL;

if (si != NULL && somain != NULL) {

/*

if (si == somain) {

s = soinfo_elf_lookup(si, elf_hash, name);

if (s != NULL) {

*lsi = si;

goto done;

}

/* Next, look for it in the preloads list */

for (int i = 0; g_ld_preloads[i] != NULL; i++) {

s = soinfo_elf_lookup(g_ld_preloads[i], elf_hash, name);

if (s != NULL) {

*lsi = g_ld_preloads[i];

goto done;

}

}

} else {

/* Order of symbol lookup is controlled by DT_SYMBOLIC flag */

/*

if (!si->has_DT_SYMBOLIC) {

DEBUG("%s: looking up %s in executable %s",

si->name, name, somain->name);

s = soinfo_elf_lookup(somain, elf_hash, name);

if (s != NULL) {

*lsi = somain;

goto done;

}

/* Next, look for it in the preloads list */

for (int i = 0; g_ld_preloads[i] != NULL; i++) {

s = soinfo_elf_lookup(g_ld_preloads[i], elf_hash, name);

if (s != NULL) {

*lsi = g_ld_preloads[i];

goto done;

}

}

}

/* Look for symbols in the local scope (the object who is

s = soinfo_elf_lookup(si, elf_hash, name);

if (s != NULL) {

*lsi = si;

goto done;

}

/*

if (si->has_DT_SYMBOLIC) {

DEBUG("%s: looking up %s in executable %s after local scope",

si->name, name, somain->name);

s = soinfo_elf_lookup(somain, elf_hash, name);

if (s != NULL) {

*lsi = somain;

goto done;

}

/* Next, look for it in the preloads list */

for (int i = 0; g_ld_preloads[i] != NULL; i++) {

s = soinfo_elf_lookup(g_ld_preloads[i], elf_hash, name);

if (s != NULL) {

*lsi = g_ld_preloads[i];

goto done;

}

}

}

}

}

for (int i = 0; needed[i] != NULL; i++) {

DEBUG("%s: looking up %s in %s",

si->name, name, needed[i]->name);

s = soinfo_elf_lookup(needed[i], elf_hash, name);

if (s != NULL) {

*lsi = needed[i];

goto done;

}

}

done:

if (s != NULL) {

TRACE_TYPE(LOOKUP, "si %s sym %s s->st_value = %p, "

"found in %s, base = %p, load bias = %p",

si->name, name, reinterpret_cast<void*>(s->st_value),

(*lsi)->name, reinterpret_cast<void*>((*lsi)->base),

reinterpret_cast<void*>((*lsi)->load_bias));

return s;

}

return NULL;

}

static LinkerAllocator<LinkedListEntry<soinfo>> g_soinfo_list_allocator_rw;

class SoinfoListAllocatorRW {

};

ElfW(Sym)* dlsym_handle_lookup(soinfo* si, soinfo** found, const char* name) {

LinkedList<soinfo, SoinfoListAllocatorRW> visit_list;

LinkedList<soinfo, SoinfoListAllocatorRW> visited;

visit_list.push_back(si);

soinfo* current_soinfo;

while ((current_soinfo = visit_list.pop_front()) != nullptr) {

if (visited.contains(current_soinfo)) {

continue;

}

ElfW(Sym)* result = soinfo_elf_lookup(current_soinfo, elfhash(name), name);

if (result != nullptr) {

*found = current_soinfo;

visit_list.clear();

visited.clear();

return result;

}

visited.push_back(current_soinfo);

current_soinfo->get_children().for_each([&](soinfo* child) {

visit_list.push_back(child);

});

}

visit_list.clear();

visited.clear();

return nullptr;

}

ElfW(Sym)* dlsym_linear_lookup(const char* name, soinfo** found, soinfo* start) {

unsigned elf_hash = elfhash(name);

if (start == NULL) {

start = solist;

}

ElfW(Sym)* s = NULL;

for (soinfo* si = start; (s == NULL) && (si != NULL); si = si->next) {

s = soinfo_elf_lookup(si, elf_hash, name);

if (s != NULL) {

*found = si;

break;

}

}

if (s != NULL) {

TRACE_TYPE(LOOKUP, "%s s->st_value = %p, found->base = %p",

name, reinterpret_cast<void*>(s->st_value), reinterpret_cast<void*>((*found)->base));

}

return s;

}

soinfo* find_containing_library(const void* p) {

ElfW(Addr) address = reinterpret_cast<ElfW(Addr)>(p);

for (soinfo* si = solist; si != NULL; si = si->next) {

if (address >= si->base && address - si->base < si->size) {

return si;

}

}

return NULL;

}

ElfW(Sym)* dladdr_find_symbol(soinfo* si, const void* addr) {

ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - si->base;

// Search the library's symbol table for any defined symbol which

// contains this address.

for (size_t i = 0; i < si->nchain; ++i) {

ElfW(Sym)* sym = &si->symtab[i];

if (sym->st_shndx != SHN_UNDEF &&

soaddr >= sym->st_value &&

soaddr < sym->st_value + sym->st_size) {

return sym;

}

}

return NULL;

}

static int open_library_on_path(const char* name, const char* const paths[]) {

}

static int open_library(const char* name) {

}

static soinfo* load_library(const char* name, int dlflags, const android_dlextinfo* extinfo) {

int fd = -1;

ScopedFd file_guard(-1);

if (extinfo != NULL && (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) != 0) {

fd = extinfo->library_fd;

} else {

// Open the file.

fd = open_library(name);

if (fd == -1) {

DL_ERR("library \"%s\" not found", name);

return NULL;

}

file_guard.reset(fd);

}

ElfReader elf_reader(name, fd);

struct stat file_stat;

if (TEMP_FAILURE_RETRY(fstat(fd, &file_stat)) != 0) {

DL_ERR("unable to stat file for the library %s: %s", name, strerror(errno));

return NULL;

}

// Check for symlink and other situations where

// file can have different names.

for (soinfo* si = solist; si != NULL; si = si->next) {

if (si->get_st_dev() != 0 &&

si->get_st_ino() != 0 &&

si->get_st_dev() == file_stat.st_dev &&

si->get_st_ino() == file_stat.st_ino) {

TRACE("library \"%s\" is already loaded under different name/path \"%s\" - will return existing soinfo", name, si->name);

return si;

}

}

if ((dlflags & RTLD_NOLOAD) != 0) {

return NULL;

}

// Read the ELF header and load the segments.

if (!elf_reader.Load(extinfo)) {

return NULL;

}

soinfo* si = soinfo_alloc(SEARCH_NAME(name), &file_stat);

if (si == NULL) {

return NULL;

}

si->base = elf_reader.load_start();

si->size = elf_reader.load_size();

si->load_bias = elf_reader.load_bias();

si->phnum = elf_reader.phdr_count();

si->phdr = elf_reader.loaded_phdr();

// At this point we know that whatever is loaded @ base is a valid ELF

// shared library whose segments are properly mapped in.

TRACE("[ load_library base=%p size=%zu name='%s' ]",

reinterpret_cast<void*>(si->base), si->size, si->name);

if (!soinfo_link_image(si, extinfo)) {

soinfo_free(si);

return NULL;

}

return si;

}

static soinfo *find_loaded_library_by_name(const char* name) {

const char* search_name = SEARCH_NAME(name);

for (soinfo* si = solist; si != NULL; si = si->next) {

if (!strcmp(search_name, si->name)) {

return si;

}

}

return NULL;

}

static soinfo* find_library_internal(const char* name, int dlflags, const android_dlextinfo* extinfo) {

if (name == NULL) {

return somain;

}

soinfo* si = find_loaded_library_by_name(name);

// Library might still be loaded, the accurate detection

// of this fact is done by load_library

if (si == NULL) {

TRACE("[ '%s' has not been found by name. Trying harder...]", name);

si = load_library(name, dlflags, extinfo);

}

if (si != NULL && (si->flags & FLAG_LINKED) == 0) {

DL_ERR("recursive link to \"%s\"", si->name);

return NULL;

}

return si;

}

static soinfo* find_library(const char* name, int dlflags, const android_dlextinfo* extinfo) {

soinfo* si = find_library_internal(name, dlflags, extinfo);

if (si != NULL) {

si->ref_count++;

}

return si;

}

static void soinfo_unload(soinfo* si) {

}

void do_android_get_LD_LIBRARY_PATH(char* buffer, size_t buffer_size) {

}

void do_android_update_LD_LIBRARY_PATH(const char* ld_library_path) {

}

soinfo* do_dlopen(const char* name, int flags, const android_dlextinfo* extinfo) {

if ((flags & ~(RTLD_NOW|RTLD_LAZY|RTLD_LOCAL|RTLD_GLOBAL|RTLD_NOLOAD)) != 0) {

DL_ERR("invalid flags to dlopen: %x", flags);

return NULL;

}

if (extinfo != NULL && ((extinfo->flags & ~(ANDROID_DLEXT_VALID_FLAG_BITS)) != 0)) {

DL_ERR("invalid extended flags to android_dlopen_ext: %" PRIx64, extinfo->flags);

return NULL;

}

protect_data(PROT_READ | PROT_WRITE);

soinfo* si = find_library(name, flags, extinfo);

if (si != NULL) {

si->CallConstructors();

}

protect_data(PROT_READ);

return si;

}

void do_dlclose(soinfo* si) {

}

#if defined(USE_RELA)

static int soinfo_relocate(soinfo* si, ElfW(Rela)* rela, unsigned count, soinfo* needed[]) {

ElfW(Sym)* s;

soinfo* lsi;

for (size_t idx = 0; idx < count; ++idx, ++rela) {

unsigned type = ELFW(R_TYPE)(rela->r_info);

unsigned sym = ELFW(R_SYM)(rela->r_info);

ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rela->r_offset + si->load_bias);

ElfW(Addr) sym_addr = 0;

const char* sym_name = NULL;

DEBUG("Processing '%s' relocation at index %zd", si->name, idx);

if (type == 0) { // R_*_NONE

continue;

}

if (sym != 0) {

sym_name = reinterpret_cast<const char*>(si->strtab + si->symtab[sym].st_name);

s = soinfo_do_lookup(si, sym_name, &lsi, needed);

if (s == NULL) {

// We only allow an undefined symbol if this is a weak reference...

s = &si->symtab[sym];

if (ELF_ST_BIND(s->st_info) != STB_WEAK) {

DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, si->name);

return -1;

}

/* IHI0044C AAELF 4.5.1.1:

switch (type) {

#if defined(__aarch64__)

case R_AARCH64_JUMP_SLOT:

case R_AARCH64_GLOB_DAT:

case R_AARCH64_ABS64:

case R_AARCH64_ABS32:

case R_AARCH64_ABS16:

case R_AARCH64_RELATIVE:

/*

break;

#elif defined(__x86_64__)

case R_X86_64_JUMP_SLOT:

case R_X86_64_GLOB_DAT:

case R_X86_64_32:

case R_X86_64_64:

case R_X86_64_RELATIVE:

// No need to do anything.

break;

case R_X86_64_PC32:

sym_addr = reloc;

break;

#endif

default:

DL_ERR("unknown weak reloc type %d @ %p (%zu)", type, rela, idx);