[ELF] Clean up native symbol resolving stuff (#3469)

Author: ksco

src/elfs/elfhacks.c

@@ -312,6 +312,8 @@ int eh_find_sym_hash(eh_obj_t *obj, const char *name, eh_sym_t *sym)
 
 	while ((sym->sym == NULL) &&
 	       (chain[idx] != STN_UNDEF)) {
+		if (chain[idx] >= obj->hash[1] /* nchain */) /* some ELF file contains broken chain! */
+			break;
 		esym = &obj->symtab[chain[idx]];
 
 		if (esym->st_name) {

src/elfs/elfloader.c

@@ -10,6 +10,7 @@
 #include <link.h>
 #include <unistd.h>
 #include <errno.h>
+#include <fnmatch.h>
 #ifndef _DLFCN_H
 #include <dlfcn.h>
 #endif
@@ -38,6 +39,7 @@
 #include "symbols.h"
 #include "cleanup.h"
 #include "globalsymbols.h"
+#include "elfhacks.h"
 #ifdef DYNAREC
 #include "dynablock.h"
 #endif
@@ -1940,72 +1942,60 @@ int NeededLibs(elfheader_t* h)
 
 typedef struct search_symbol_s{
     const char* name;
-    void*       addr;
-    void*       lib;
+    void* addr;
 } search_symbol_t;
-int dl_iterate_phdr_findsymbol(struct dl_phdr_info* info, size_t size, void* data)
+
+int dl_iterate_phdr_findsymbol(eh_obj_t* obj, search_symbol_t* s)
 {
-    search_symbol_t* s = (search_symbol_t*)data;
+    // special case for dlsym -- it's not a versionned symbol in libMangoHud_shim.so.
+    if (!fnmatch("*libMangoHud_shim.so*", obj->name, 0) && !strcmp(s->name, "dlsym")) {
+        eh_find_sym(obj, "dlsym", &s->addr);
+        eh_destroy_obj(obj);
+        return !!s->addr;
+    }
 
-    for(int j = 0; j<info->dlpi_phnum; ++j) {
-        if (info->dlpi_phdr[j].p_type == PT_DYNAMIC) {
-            ElfW(Sym)* sym = NULL;
-            ElfW(Word) sym_cnt = 0;
+    for (int j = 0; j < obj->phnum; ++j) {
+        if (obj->phdr[j].p_type == PT_DYNAMIC) {
             ElfW(Verdef)* verdef = NULL;
             ElfW(Word) verdef_cnt = 0;
-            char *strtab = NULL;
-            ElfW(Dyn)* dyn = (ElfW(Dyn)*)(info->dlpi_addr +  info->dlpi_phdr[j].p_vaddr); //Dynamic Section
+            char* strtab = NULL;
+            ElfW(Dyn)* dyn = (ElfW(Dyn)*)(obj->addr + obj->phdr[j].p_vaddr);
             // grab the needed info
-            while(dyn->d_tag != DT_NULL) {
-                switch(dyn->d_tag) {
+            while (dyn->d_tag != DT_NULL) {
+                switch (dyn->d_tag) {
                     case DT_STRTAB:
-                        strtab = (char *)(dyn->d_un.d_ptr);
+                        strtab = (char*)(dyn->d_un.d_ptr);
                         break;
                     case DT_VERDEF:
-                        verdef = (ElfW(Verdef)*)(info->dlpi_addr +  dyn->d_un.d_ptr);
+                        verdef = (ElfW(Verdef)*)(obj->addr + dyn->d_un.d_ptr);
                         break;
                     case DT_VERDEFNUM:
                         verdef_cnt = dyn->d_un.d_val;
                         break;
                 }
                 ++dyn;
             }
-            if(strtab && verdef && verdef_cnt) {
-                if((uintptr_t)strtab < (uintptr_t)info->dlpi_addr) // this test is need for linux-vdso on PI and some other OS (looks like a bug to me)
-                    strtab=(char*)((uintptr_t)strtab + info->dlpi_addr);
-                // Look fr all defined versions now
-                ElfW(Verdef)* v = verdef;
-                while(v) {
-                    ElfW(Verdaux)* vda = (ElfW(Verdaux)*)(((uintptr_t)v) + v->vd_aux);
-                    if(v->vd_version>0 && !v->vd_flags)
-                        for(int i=0; i<v->vd_cnt; ++i) {
-                            const char* vername = (strtab+vda->vda_name);
-                            if(vername && vername[0] && (s->addr = dlvsym(s->lib, s->name, vername))) {
-                                printf_log(/*LOG_DEBUG*/LOG_INFO, "Found symbol with version %s, value = %p\n", vername, s->addr);
-                                return 1;   // stop searching
-                            }
-                            vda = (ElfW(Verdaux)*)(((uintptr_t)vda) + vda->vda_next);
-                        }
-                    v = v->vd_next?(ElfW(Verdef)*)((uintptr_t)v + v->vd_next):NULL;
+
+            if (strtab && verdef && verdef_cnt) {
+                eh_find_sym(obj, s->name, &s->addr);
+                if (s->addr) {
+                    eh_destroy_obj(obj);
+                    return 1;
                 }
             }
         }
     }
+
+    eh_destroy_obj(obj);
     return 0;
 }
 
 void* GetNativeSymbolUnversioned(void* lib, const char* name)
 {
-    // try to find "name" in loaded elf, whithout checking for the symbol version (like dlsym, but no version check)
     search_symbol_t s;
     s.name = name;
     s.addr = NULL;
-    if(lib)
-        s.lib = lib;
-    else
-        s.lib = my_context->box64lib;
-    printf_log(LOG_INFO, "Look for %s in loaded elfs\n", name);
-    dl_iterate_phdr(dl_iterate_phdr_findsymbol, &s);
+    eh_iterate_obj((eh_iterate_obj_callback_func)dl_iterate_phdr_findsymbol, &s);
     return s.addr;
 }
 

src/libtools/libdl.c

@@ -62,38 +62,9 @@ static void*(*real_dlopen)(const char*, int) = NULL;
 static int (*real_dlclose)(void*) = NULL;
 static void* (*real_dlsym)(void*, const char*) = NULL;
 
-static void get_real_dlsym(void)
-{
-    eh_obj_t libdl;
-    int ret;
-
-    const char* libs[] = {
-        "*libMangoHud_shim.so*",
-#if defined(__GLIBC__)
-        "*libdl.so*",
-#endif
-        "*libc.so*",
-        "*libc.*.so*",
-        "*ld-musl-*.so*",
-    };
-
-    for (size_t i = 0; i < sizeof(libs) / sizeof(*libs); i++) {
-        ret = eh_find_obj(&libdl, libs[i]);
-        if (ret) {
-            continue;
-        }
-        eh_find_sym(&libdl, "dlsym", (void**)&real_dlsym);
-        eh_destroy_obj(&libdl);
-        if (real_dlsym) break;
-    }
-}
-
-
 EXPORT void* dlopen(const char* path, int flags)
 {
-    if(!real_dlopen) {
-        real_dlopen = GetNativeSymbolUnversioned(RTLD_NEXT, "dlopen");
-    }
+    if (!real_dlopen) real_dlopen = GetNativeSymbolUnversioned(RTLD_NEXT, "dlopen");
 
     // will look only for libs loaded with full path (and only on 64bits for now)
     if(path && strchr(path, '/') && (/*(box64_is32bits && FileIsX86ELF(path)) ||*/ (!box64_is32bits && FileIsX64ELF(path)))) {
@@ -120,9 +91,7 @@ EXPORT void* dlopen(const char* path, int flags)
 
 EXPORT int dlclose(void* handle)
 {
-    if (!real_dlclose) {
-        real_dlclose = GetNativeSymbolUnversioned(RTLD_NEXT, "dlclose");
-    }
+    if (!real_dlclose) real_dlclose = GetNativeSymbolUnversioned(RTLD_NEXT, "dlclose");
 
     if((uintptr_t)handle>=HOOKLIB && (uintptr_t)handle<HOOKLIB+hooked_size) {
         uint32_t i = (uintptr_t)handle-HOOKLIB;
@@ -137,7 +106,7 @@ EXPORT int dlclose(void* handle)
 
 EXPORT void* dlsym(void* handle, const char* symbol)
 {
-    if (!real_dlsym) get_real_dlsym();
+    if (!real_dlsym) real_dlsym = GetNativeSymbolUnversioned(RTLD_NEXT, "dlsym");
 
     if((uintptr_t)handle>=HOOKLIB && (uintptr_t)handle<HOOKLIB+hooked_size) {
         uint32_t i = (uintptr_t)handle-HOOKLIB;