#define ALLOW_ZERO_PLTGOT
-#if USE_TLS
+#if defined(USE_TLS) && USE_TLS
#include "dl-tls.c"
#endif
/* Global variables used within the shared library loader */
char *_dl_library_path = NULL; /* Where we look for libraries */
+#ifdef __LDSO_PRELOAD_ENV_SUPPORT__
char *_dl_preload = NULL; /* Things to be loaded before the libs */
+#endif
char *_dl_ldsopath = NULL; /* Location of the shared lib loader */
int _dl_errno = 0; /* We can't use the real errno in ldso */
size_t _dl_pagesize = 0; /* Store the page size for use later */
#ifdef __UCLIBC_HAS_SSP__
# include <dl-osinfo.h>
-uintptr_t stack_chk_guard;
+static uintptr_t stack_chk_guard;
# ifndef THREAD_SET_STACK_GUARD
/* Only exported for architectures that don't store the stack guard canary
* in local thread area. */
uintptr_t __stack_chk_guard attribute_relro;
-# ifdef __UCLIBC_HAS_SSP_COMPAT__
-strong_alias(__stack_chk_guard,__guard)
-# endif
-# elif __UCLIBC_HAS_SSP_COMPAT__
+# endif
+# ifdef __UCLIBC_HAS_SSP_COMPAT__
uintptr_t __guard attribute_relro;
# endif
#endif
(*_dl_free_function) (p);
}
-#if USE_TLS
+#if defined(USE_TLS) && USE_TLS
void *_dl_memalign(size_t __boundary, size_t __size)
{
void *result;
ElfW(Addr) relro_addr = 0;
size_t relro_size = 0;
struct stat st;
-#if USE_TLS
+#if defined(USE_TLS) && USE_TLS
void *tcbp = NULL;
#endif
auxvt[AT_UID].a_un.a_val == auxvt[AT_EUID].a_un.a_val &&
auxvt[AT_GID].a_un.a_val == auxvt[AT_EGID].a_un.a_val)) {
_dl_secure = 0;
+#ifdef __LDSO_PRELOAD_ENV_SUPPORT__
_dl_preload = _dl_getenv("LD_PRELOAD", envp);
+#endif
_dl_library_path = _dl_getenv("LD_LIBRARY_PATH", envp);
} else {
static const char unsecure_envvars[] =
/* We could use rawmemchr but this need not be fast. */
nextp = _dl_strchr(nextp, '\0') + 1;
} while (*nextp != '\0');
+#ifdef __LDSO_PRELOAD_ENV_SUPPORT__
_dl_preload = NULL;
+#endif
_dl_library_path = NULL;
/* SUID binaries can be exploited if they do LAZY relocation. */
unlazy = RTLD_NOW;
}
-#if USE_TLS
+#if defined(USE_TLS) && USE_TLS
_dl_error_catch_tsd = &_dl_initial_error_catch_tsd;
_dl_init_static_tls = &_dl_nothread_init_static_tls;
#endif
-#ifdef __UCLIBC_HAS_SSP__
- /* Set up the stack checker's canary. */
- stack_chk_guard = _dl_setup_stack_chk_guard ();
-# ifdef THREAD_SET_STACK_GUARD
- THREAD_SET_STACK_GUARD (stack_chk_guard);
-# ifdef __UCLIBC_HAS_SSP_COMPAT__
- __guard = stack_chk_guard;
-# endif
-# else
- __stack_chk_guard = stack_chk_guard;
-# endif
-#endif
-
/* At this point we are now free to examine the user application,
* and figure out which libraries are supposed to be called. Until
* we have this list, we will not be completely ready for dynamic
/* Discover any TLS sections if the target supports them. */
if (ppnt->p_type == PT_TLS) {
-#if USE_TLS
+#if defined(USE_TLS) && USE_TLS
if (ppnt->p_memsz > 0) {
app_tpnt->l_tls_blocksize = ppnt->p_memsz;
app_tpnt->l_tls_align = ppnt->p_align;
app_tpnt->relro_addr = relro_addr;
app_tpnt->relro_size = relro_size;
-#if USE_TLS
+#if defined(USE_TLS) && USE_TLS
/*
* Adjust the address of the TLS initialization image in
* case the executable is actually an ET_DYN object.
_dl_map_cache();
+#ifdef __LDSO_PRELOAD_ENV_SUPPORT__
if (_dl_preload) {
char c, *str, *str2;
str++;
}
}
+#endif /* __LDSO_PRELOAD_ENV_SUPPORT__ */
#ifdef __LDSO_PRELOAD_FILE_SUPPORT__
do {
- struct stat st;
char *preload;
int fd;
char c, *cp, *cp2;
tpnt1 = _dl_load_shared_library(0, &rpnt, NULL, cp2, trace_loaded_objects);
if (!tpnt1) {
-#ifdef __LDSO_LDD_SUPPORT__
+# ifdef __LDSO_LDD_SUPPORT__
if (trace_loaded_objects)
_dl_dprintf(1, "\t%s => not found\n", cp2);
else
-#endif
+# endif
{
_dl_dprintf(_dl_debug_file, "%s: can't load library '%s'\n", _dl_progname, cp2);
_dl_exit(15);
_dl_debug_early("Loading: (%x) %s\n", DL_LOADADDR_BASE(tpnt1->loadaddr), tpnt1->libname);
-#ifdef __LDSO_LDD_SUPPORT__
+# ifdef __LDSO_LDD_SUPPORT__
if (trace_loaded_objects &&
tpnt1->usage_count == 1) {
_dl_dprintf(1, "\t%s => %s (%x)\n",
cp2, tpnt1->libname,
DL_LOADADDR_BASE(tpnt1->loadaddr));
}
-#endif
+# endif
}
/* find start of next library */
ElfW(Ehdr) *epnt = (ElfW(Ehdr) *) auxvt[AT_BASE].a_un.a_val;
ElfW(Phdr) *myppnt = (ElfW(Phdr) *) DL_RELOC_ADDR(load_addr, epnt->e_phoff);
int j;
-
+#ifdef __DSBT__
+ struct elf_resolve *ref = _dl_loaded_modules;
+ _dl_if_debug_dprint("ref is %x, dsbt %x, ref-dsbt %x size %x\n",
+ ref, tpnt->loadaddr.map->dsbt_table,
+ ref->loadaddr.map->dsbt_table,
+ tpnt->loadaddr.map->dsbt_size);
+
+ _dl_memcpy(tpnt->loadaddr.map->dsbt_table, ref->loadaddr.map->dsbt_table,
+ tpnt->loadaddr.map->dsbt_size * sizeof(unsigned *));
+#endif
tpnt = _dl_add_elf_hash_table(tpnt->libname, load_addr,
tpnt->dynamic_info,
(unsigned long)tpnt->dynamic_addr,
}
#endif
-#if USE_TLS
+#if defined(USE_TLS) && USE_TLS
/* We do not initialize any of the TLS functionality unless any of the
* initial modules uses TLS. This makes dynamic loading of modules with
* TLS impossible, but to support it requires either eagerly doing setup
tcbp = init_tls ();
}
#endif
+#ifdef __UCLIBC_HAS_SSP__
+ /* Set up the stack checker's canary. */
+ stack_chk_guard = _dl_setup_stack_chk_guard ();
+# ifdef THREAD_SET_STACK_GUARD
+ THREAD_SET_STACK_GUARD (stack_chk_guard);
+# else
+ __stack_chk_guard = stack_chk_guard;
+# endif
+# ifdef __UCLIBC_HAS_SSP_COMPAT__
+ __guard = stack_chk_guard;
+# endif
+#endif
+
_dl_debug_early("Beginning relocation fixups\n");
_dl_protect_relro (tpnt);
}
-#if USE_TLS
+#if defined(USE_TLS) && USE_TLS
if (!was_tls_init_tp_called && _dl_tls_max_dtv_idx > 0)
++_dl_tls_generation;
_dl_malloc_function = (void* (*)(size_t)) (intptr_t) _dl_find_hash(__C_SYMBOL_PREFIX__ "malloc",
_dl_symbol_tables, NULL, ELF_RTYPE_CLASS_PLT, NULL);
-#if USE_TLS
+#if defined(USE_TLS) && USE_TLS
/* Find the real functions and make ldso functions use them from now on */
_dl_calloc_function = (void* (*)(size_t, size_t)) (intptr_t)
_dl_find_hash(__C_SYMBOL_PREFIX__ "calloc", _dl_symbol_tables, NULL, ELF_RTYPE_CLASS_PLT, NULL);