void update_environment(char* base_path) { /* Set the following environment variables: 1) PIN_VM_LD_LIBRARY_PATH (put pin_libs in front of existing LD_LIBRARY_PATH) 2) PIN_LD_RESTORE_REQUIRED (set it to "t") 3) PIN_APP_LD_LIBRARY_PATH (copy of LD_LIBRARY_PATH (if set)) 4) PIN_APP_LD_ASSUME_KERNEL (copy of LD_ASSUME_KERNEL (if set)) 4a) PIN_APP_LD_BIND_NOW 4b) PIN_APP_LD_PRELOAD 5) unset LD_ASSUME_KERNEL 6) LD_LIBRARY_PATH (injector_libs before users's LD_LIBRARY_PATH) On Unix systems, we run pinbin instead of pin. */ int r; int gcc_major = 0, gcc_minor = 0; const int overwrite = 1; char* pin_ld_library_path = 0; char* new_ld_library_path = 0; const char* pin_runtime_dir = "runtime"; const char* glibc_lib_dir = "glibc"; const char* cpp_lib_dir = "cpplibs"; char* ld_library_path = 0; char* ld_assume_kernel = 0; char* base_path32 = 0; char* base_path64 = 0; char* pin_runtime_libs32 = 0; char* pin_runtime_libs64 = 0; char* pin_glibc_libs32 = 0; char* pin_glibc_libs64 = 0; char* pin_cpp_libs32 = 0; char* pin_cpp_libs64 = 0; char* incoming_ld_preload = 0; char* incoming_ld_bind_now = 0; int getGccPassed = 0; base_path32 = append3(base_path, "/", "ia32"); base_path64 = append3(base_path, "/", "intel64"); /* make pin_libs - required for pin/vm */ pin_runtime_libs32 = append3(base_path32, "/", pin_runtime_dir); pin_runtime_libs64 = append3(base_path64, "/", pin_runtime_dir); pin_glibc_libs32 = append3(pin_runtime_libs32, "/", glibc_lib_dir); pin_glibc_libs64 = append3(pin_runtime_libs64, "/", glibc_lib_dir); pin_cpp_libs32 = append3(pin_runtime_libs32, "/", cpp_lib_dir);; pin_cpp_libs64 = append3(pin_runtime_libs64, "/", cpp_lib_dir);; /* make pin_ld_library_path pre-pending pin_libs -- for the VM ultimately */ ld_library_path = getenv("LD_LIBRARY_PATH"); pin_ld_library_path = ld_library_path; /* must be first (so added last) */ pin_ld_library_path = append3(pin_glibc_libs32, ":", pin_ld_library_path); pin_ld_library_path = append3(pin_glibc_libs64, ":", pin_ld_library_path); getGccPassed = get_gcc_version_string(&gcc_major, &gcc_minor); if (!getGccPassed || gcc_major < 4 || (gcc_major == 4 && gcc_minor < 5)) { pin_ld_library_path = append3(pin_cpp_libs32, ":", pin_ld_library_path); pin_ld_library_path = append3(pin_cpp_libs64, ":", pin_ld_library_path); } pin_ld_library_path = append3(pin_runtime_libs32, ":", pin_ld_library_path); pin_ld_library_path = append3(pin_runtime_libs64, ":", pin_ld_library_path); /* make new_ld_library_path pre-pending injector_libs */ new_ld_library_path = ld_library_path; if (!getGccPassed || gcc_major < 4 || (gcc_major == 4 && gcc_minor < 5)) { new_ld_library_path = append3(pin_cpp_libs32, ":", new_ld_library_path); new_ld_library_path = append3(pin_cpp_libs64, ":", new_ld_library_path); } /* must be first (so added last) */ new_ld_library_path = append3(pin_runtime_libs32, ":", new_ld_library_path); new_ld_library_path = append3(pin_runtime_libs64, ":", new_ld_library_path); /* This variable tells the injector to restore environment variables after pin is injected. */ r = setenv("PIN_LD_RESTORE_REQUIRED", "t", overwrite); check_retval(r, "setenv PIN_LD_RESTORE_REQUIRED"); /* Set the pin vm library path. */ r = setenv("PIN_VM_LD_LIBRARY_PATH", pin_ld_library_path, overwrite); check_retval(r, "setenv PIN_VM_LD_LIBRARY_PATH"); /* * Backup the LD_LIBRARY_PATH, since pin uses a different one while launching. It will be restored * when the app is loaded to memory. */ if (ld_library_path) { r = setenv("PIN_APP_LD_LIBRARY_PATH", ld_library_path, overwrite); check_retval(r, "setenv PIN_APP_LD_LIBRARY_PATH"); } /* Overwrite LD_LIBRARY_PATH with the libraries required for pin to run. */ r = setenv("LD_LIBRARY_PATH", new_ld_library_path, overwrite); check_retval(r, "setenv LD_LIBRARY_PATH"); /* * If the LD_BIND_NOW, LD_ASSUME_KERNEL and LD_PRELOAD variables were defined they should pass as * is to the app. Since pin's injector doesn't need it, we save them now and restore it after * pin is injected into the process. */ ld_assume_kernel = getenv("LD_ASSUME_KERNEL"); if (ld_assume_kernel) { r = setenv("PIN_APP_LD_ASSUME_KERNEL", ld_assume_kernel, overwrite); check_retval(r, "setenv PIN_APP_LD_ASSUME_KERNEL"); unsetenv("LD_ASSUME_KERNEL"); } incoming_ld_bind_now = getenv("LD_BIND_NOW"); if (incoming_ld_bind_now) { r = setenv("PIN_APP_LD_BIND_NOW", incoming_ld_bind_now, overwrite); check_retval(r, "setenv PIN_APP_LD_BIND_NOW"); unsetenv("LD_BIND_NOW"); } incoming_ld_preload = getenv("LD_PRELOAD"); if (incoming_ld_preload) { r = setenv("PIN_APP_LD_PRELOAD", incoming_ld_preload, overwrite); check_retval(r, "setenv PIN_APP_LD_PRELOAD"); unsetenv("LD_PRELOAD"); } }
int dbg_help_client_t::init(char* path) { DWORD64 dwBaseAddr=0; int chars; char exe_path[MAX_PATH]; chars = GetModuleFileName(NULL, exe_path, MAX_PATH); if (chars == 0) { fprintf(stderr,"Could not find base path for XED executable\n"); fflush(stderr); exit(1); } //fprintf(stderr,"EXE PATH %s\n", exe_path); char* dir = find_base_path(exe_path); //fprintf(stderr,"DIR %s\n", dir); char* dbghelp = append3(dir,"\\","dbghelp.dll"); //fprintf(stderr,"DBGHLP %s\n", dbghelp); if (_access_s(dbghelp,4) != 0) { //fprintf(stderr, // "WARNING: Could not find dbghelp.dll in xed.exe directory\n"); //fflush(stderr); return 0; } //fprintf(stderr,"FOUND DBGHELP\n"); if (validate_version(dbghelp)) { fprintf(stderr, "WARNING: dbghelp.dll version is too old\n"); fflush(stderr); return 0; } //FIXME: Add a version check for the dll ( ImagehlpApiVersion is NOT //the right thing) SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS); hProcess = GetCurrentProcess(); if (SymInitialize(hProcess, NULL, FALSE)) { // nothing } else { error = GetLastError(); fprintf(stderr,"SymInitialize returned error : %d 0x%x\n", error, error); fflush(stderr); return 0; } actual_base = SymLoadModuleEx(hProcess, NULL, path, NULL, dwBaseAddr, 0, NULL, 0); if (actual_base) { // nothing } else { error = GetLastError(); fprintf(stderr,"SymLoadModuleEx returned error : %d 0x%x\n", error, error); fflush(stderr); return 0; } if (SymEnumerateModules64(hProcess, (PSYM_ENUMMODULES_CALLBACK64)enum_modules, this)) { // nothing } else { error = GetLastError(); fprintf(stderr,"SymEnumerateModules64 returned error : %d 0x%x\n", error, error); fflush(stderr); return 0; } if (SymEnumSymbols(hProcess, actual_base, 0, enum_sym, this)) { // nothing } else { error = GetLastError(); fprintf(stderr,"SymEnumSymbols failed: %d 0x%x\n", error, error); fflush(stderr); return 0; } make_symbol_vector(&sym_tab); initialized = true; return 1; }