Edit
IABSD.fr/xenocara/dist/libepoxy/test/dlwrap.c
matthieu
- dist/libepoxy/test/dlwrap.c
-
/* Copyright © 2013, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ /** @file dlwrap.c * * Implements a wrapper for dlopen() and dlsym() so that epoxy will * end up finding symbols from the testcases named * "override_EGL_eglWhatever()" or "override_GLES2_glWhatever()" or * "override_GL_glWhatever()" when it tries to dlopen() and dlsym() * the real GL or EGL functions in question. * * This lets us simulate some target systems in the test suite, or * just stub out GL functions so we can be sure of what's being * called. */ /* dladdr is a glibc extension */ #define _GNU_SOURCE #include <dlfcn.h> #include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> #include "dlwrap.h" #define STRNCMP_LITERAL(var, literal) \ strncmp ((var), (literal), sizeof (literal) - 1) #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0])) void *libfips_handle; typedef void *(*fips_dlopen_t)(const char *filename, int flag); typedef void *(*fips_dlsym_t)(void *handle, const char *symbol); void *override_EGL_eglGetProcAddress(const char *name); void *override_GL_glXGetProcAddress(const char *name); void *override_GL_glXGetProcAddressARB(const char *name); void __dlclose(void *handle); static struct libwrap { const char *filename; const char *symbol_prefix; void *handle; } wrapped_libs[] = { { "libGL.so", "GL", NULL }, { "libEGL.so", "EGL", NULL }, { "libGLESv2.so", "GLES2", NULL }, { "libOpenGL.so", "GL", NULL}, }; /* Match 'filename' against an internal list of libraries for which * libfips has wrappers. * * Returns true and sets *index_ret if a match is found. * Returns false if no match is found. */ static struct libwrap * find_wrapped_library(const char *filename) { unsigned i; if (!filename) return NULL; for (i = 0; i < ARRAY_SIZE(wrapped_libs); i++) { if (strncmp(wrapped_libs[i].filename, filename, strlen(wrapped_libs[i].filename)) == 0) { return &wrapped_libs[i]; } } return NULL; } /* Many (most?) OpenGL programs dlopen libGL.so.1 rather than linking * against it directly, which means they would not be seeing our * wrapped GL symbols via LD_PRELOAD. So we catch the dlopen in a * wrapper here and redirect it to our library. */ void * dlopen(const char *filename, int flag) { void *ret; struct libwrap *wrap; /* Before deciding whether to redirect this dlopen to our own * library, we call the real dlopen. This assures that any * expected side-effects from loading the intended library are * resolved. Below, we may still return a handle pointing to * our own library, and not what is opened here. */ ret = dlwrap_real_dlopen(filename, flag); /* If filename is not a wrapped library, just return real dlopen */ wrap = find_wrapped_library(filename); if (!wrap) return ret; wrap->handle = ret; /* We use wrapped_libs as our handles to libraries. */ return wrap; } /** * Wraps dlclose to hide our faked handles from it. */ void __dlclose(void *handle) { struct libwrap *wrap = handle; if (wrap < wrapped_libs || wrap >= wrapped_libs + ARRAY_SIZE(wrapped_libs)) { void (*real_dlclose)(void *handle) = dlwrap_real_dlsym(RTLD_NEXT, "__dlclose"); real_dlclose(handle); } } void * dlwrap_real_dlopen(const char *filename, int flag) { static fips_dlopen_t real_dlopen = NULL; if (!real_dlopen) { real_dlopen = (fips_dlopen_t) dlwrap_real_dlsym(RTLD_NEXT, "dlopen"); if (!real_dlopen) { fputs("Error: Failed to find symbol for dlopen.\n", stderr); exit(1); } } return real_dlopen(filename, flag); } /** * Return the dlsym() on the application's namespace for * "override_<prefix>_<name>" */ static void * wrapped_dlsym(const char *prefix, const char *name) { char *wrap_name; void *symbol; if (asprintf(&wrap_name, "override_%s_%s", prefix, name) < 0) { fputs("Error: Failed to allocate memory.\n", stderr); abort(); } symbol = dlwrap_real_dlsym(RTLD_DEFAULT, wrap_name); free(wrap_name); return symbol; } /* Since we redirect dlopens of libGL.so and libEGL.so to libfips we * need to ensure that dlysm succeeds for all functions that might be * defined in the real, underlying libGL library. But we're far too * lazy to implement wrappers for function that would simply * pass-through, so instead we also wrap dlysm and arrange for it to * pass things through with RTLD_next if libfips does not have the * function desired. */ void * dlsym(void *handle, const char *name) { struct libwrap *wrap = handle; /* Make sure that handle is actually one of our wrapped libs. */ if (wrap < wrapped_libs || wrap >= wrapped_libs + ARRAY_SIZE(wrapped_libs)) { wrap = NULL; } /* Failing that, anything specifically requested from the * libfips library should be redirected to a real GL * library. */ if (wrap) { void *symbol = wrapped_dlsym(wrap->symbol_prefix, name); if (symbol) return symbol; else return dlwrap_real_dlsym(wrap->handle, name); } /* And anything else is some unrelated dlsym. Just pass it * through. (This also covers the cases of lookups with * special handles such as RTLD_DEFAULT or RTLD_NEXT.) */ return dlwrap_real_dlsym(handle, name); } void * dlwrap_real_dlsym(void *handle, const char *name) { static fips_dlsym_t real_dlsym = NULL; if (!real_dlsym) { /* FIXME: This brute-force, hard-coded searching for a versioned * symbol is really ugly. The only reason I'm doing this is because * I need some way to lookup the "dlsym" function in libdl, but * I can't use 'dlsym' to do it. So dlvsym works, but forces me * to guess what the right version is. * * Potential fixes here: * * 1. Use libelf to actually inspect libdl.so and * find the right version, (finding the right * libdl.so can be made easier with * dl_iterate_phdr). * * 2. Use libelf to find the offset of the 'dlsym' * symbol within libdl.so, (and then add this to * the base address at which libdl.so is loaded * as reported by dl_iterate_phdr). * * In the meantime, I'll just keep augmenting this * hard-coded version list as people report bugs. */ const char *version[] = { "GLIBC_2.17", "GLIBC_2.4", "GLIBC_2.3", "GLIBC_2.2.5", "GLIBC_2.2", "GLIBC_2.0", "FBSD_1.0" }; int num_versions = sizeof(version) / sizeof(version[0]); int i; for (i = 0; i < num_versions; i++) { real_dlsym = (fips_dlsym_t) dlvsym(RTLD_NEXT, "dlsym", version[i]); if (real_dlsym) break; } if (i == num_versions) { fputs("Internal error: Failed to find real dlsym\n", stderr); fputs("This may be a simple matter of fips not knowing about the version of GLIBC that\n" "your program is using. Current known versions are:\n\n\t", stderr); for (i = 0; i < num_versions; i++) fprintf(stderr, "%s ", version[i]); fputs("\n\nYou can inspect your version by first finding libdl.so.2:\n" "\n" "\tldd <your-program> | grep libdl.so\n" "\n" "And then inspecting the version attached to the dlsym symbol:\n" "\n" "\treadelf -s /path/to/libdl.so.2 | grep dlsym\n" "\n" "And finally, adding the version to dlwrap.c:dlwrap_real_dlsym.\n", stderr); exit(1); } } return real_dlsym(handle, name); } void * override_GL_glXGetProcAddress(const char *name) { void *symbol; symbol = wrapped_dlsym("GL", name); if (symbol) return symbol; return DEFER_TO_GL("libGL.so.1", override_GL_glXGetProcAddress, "glXGetProcAddress", (name)); } void * override_GL_glXGetProcAddressARB(const char *name) { void *symbol; symbol = wrapped_dlsym("GL", name); if (symbol) return symbol; return DEFER_TO_GL("libGL.so.1", override_GL_glXGetProcAddressARB, "glXGetProcAddressARB", (name)); } void * override_EGL_eglGetProcAddress(const char *name) { void *symbol; if (!STRNCMP_LITERAL(name, "gl")) { symbol = wrapped_dlsym("GLES2", name); if (symbol) return symbol; } if (!STRNCMP_LITERAL(name, "egl")) { symbol = wrapped_dlsym("EGL", name); if (symbol) return symbol; } return DEFER_TO_GL("libEGL.so.1", override_EGL_eglGetProcAddress, "eglGetProcAddress", (name)); }