diff options
Diffstat (limited to 'lib/interception/interception.h')
| -rw-r--r-- | lib/interception/interception.h | 110 |
1 files changed, 75 insertions, 35 deletions
diff --git a/lib/interception/interception.h b/lib/interception/interception.h index b72bff2a6c02..030bda7cba0c 100644 --- a/lib/interception/interception.h +++ b/lib/interception/interception.h @@ -19,6 +19,17 @@ # error "Interception doesn't work on this operating system." #endif +#include "sanitizer/common_interface_defs.h" + +// These typedefs should be used only in the interceptor definitions to replace +// the standard system types (e.g. SSIZE_T instead of ssize_t) +typedef __sanitizer::uptr SIZE_T; +typedef __sanitizer::sptr SSIZE_T; +typedef __sanitizer::sptr PTRDIFF_T; +typedef __sanitizer::s64 INTMAX_T; +typedef __sanitizer::u64 OFF_T; +typedef __sanitizer::u64 OFF64_T; + // How to use this library: // 1) Include this header to define your own interceptors // (see details below). @@ -75,12 +86,22 @@ // mach_override, a handy framework for patching functions at runtime. // To avoid possible name clashes, our replacement functions have // the "wrap_" prefix on Mac. +// An alternative to function patching is to create a dylib containing a +// __DATA,__interpose section that associates library functions with their +// wrappers. When this dylib is preloaded before an executable using +// DYLD_INSERT_LIBRARIES, it routes all the calls to interposed functions done +// through stubs to the wrapper functions. Such a library is built with +// -DMAC_INTERPOSE_FUNCTIONS=1. + +#if !defined(MAC_INTERPOSE_FUNCTIONS) || !defined(__APPLE__) +# define MAC_INTERPOSE_FUNCTIONS 0 +#endif #if defined(__APPLE__) # define WRAP(x) wrap_##x # define WRAPPER_NAME(x) "wrap_"#x # define INTERCEPTOR_ATTRIBUTE -# define DECLARE_WRAPPER(ret_type, convention, func, ...) +# define DECLARE_WRAPPER(ret_type, func, ...) #elif defined(_WIN32) # if defined(_DLL) // DLL CRT # define WRAP(x) x @@ -91,63 +112,82 @@ # define WRAPPER_NAME(x) "wrap_"#x # define INTERCEPTOR_ATTRIBUTE # endif -# define DECLARE_WRAPPER(ret_type, convention, func, ...) +# define DECLARE_WRAPPER(ret_type, func, ...) #else # define WRAP(x) __interceptor_ ## x # define WRAPPER_NAME(x) "__interceptor_" #x # define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default"))) -# define DECLARE_WRAPPER(ret_type, convention, func, ...) \ - extern "C" ret_type convention func(__VA_ARGS__) \ +# define DECLARE_WRAPPER(ret_type, func, ...) \ + extern "C" ret_type func(__VA_ARGS__) \ __attribute__((weak, alias("__interceptor_" #func), visibility("default"))); #endif -#define PTR_TO_REAL(x) real_##x -#define REAL(x) __interception::PTR_TO_REAL(x) -#define FUNC_TYPE(x) x##_f - -#define DECLARE_REAL(ret_type, func, ...) \ - typedef ret_type (*FUNC_TYPE(func))(__VA_ARGS__); \ - namespace __interception { \ - extern FUNC_TYPE(func) PTR_TO_REAL(func); \ - } +#if !MAC_INTERPOSE_FUNCTIONS +# define PTR_TO_REAL(x) real_##x +# define REAL(x) __interception::PTR_TO_REAL(x) +# define FUNC_TYPE(x) x##_f + +# define DECLARE_REAL(ret_type, func, ...) \ + typedef ret_type (*FUNC_TYPE(func))(__VA_ARGS__); \ + namespace __interception { \ + extern FUNC_TYPE(func) PTR_TO_REAL(func); \ + } +#else // MAC_INTERPOSE_FUNCTIONS +# define REAL(x) x +# define DECLARE_REAL(ret_type, func, ...) \ + extern "C" ret_type func(__VA_ARGS__); +#endif // MAC_INTERPOSE_FUNCTIONS #define DECLARE_REAL_AND_INTERCEPTOR(ret_type, func, ...) \ - DECLARE_REAL(ret_type, func, ##__VA_ARGS__) \ + DECLARE_REAL(ret_type, func, __VA_ARGS__) \ extern "C" ret_type WRAP(func)(__VA_ARGS__); -// FIXME(timurrrr): We might need to add DECLARE_REAL_EX etc to support -// different calling conventions later. - -#define DEFINE_REAL_EX(ret_type, convention, func, ...) \ - typedef ret_type (convention *FUNC_TYPE(func))(__VA_ARGS__); \ - namespace __interception { \ - FUNC_TYPE(func) PTR_TO_REAL(func); \ - } - // Generally, you don't need to use DEFINE_REAL by itself, as INTERCEPTOR // macros does its job. In exceptional cases you may need to call REAL(foo) // without defining INTERCEPTOR(..., foo, ...). For example, if you override // foo with an interceptor for other function. -#define DEFAULT_CONVENTION - -#define DEFINE_REAL(ret_type, func, ...) \ - DEFINE_REAL_EX(ret_type, DEFAULT_CONVENTION, func, __VA_ARGS__) +#if !MAC_INTERPOSE_FUNCTIONS +# define DEFINE_REAL(ret_type, func, ...) \ + typedef ret_type (*FUNC_TYPE(func))(__VA_ARGS__); \ + namespace __interception { \ + FUNC_TYPE(func) PTR_TO_REAL(func); \ + } +#else +# define DEFINE_REAL(ret_type, func, ...) +#endif -#define INTERCEPTOR_EX(ret_type, convention, func, ...) \ - DEFINE_REAL_EX(ret_type, convention, func, __VA_ARGS__) \ - DECLARE_WRAPPER(ret_type, convention, func, __VA_ARGS__) \ +#define INTERCEPTOR(ret_type, func, ...) \ + DEFINE_REAL(ret_type, func, __VA_ARGS__) \ + DECLARE_WRAPPER(ret_type, func, __VA_ARGS__) \ extern "C" \ INTERCEPTOR_ATTRIBUTE \ - ret_type convention WRAP(func)(__VA_ARGS__) - -#define INTERCEPTOR(ret_type, func, ...) \ - INTERCEPTOR_EX(ret_type, DEFAULT_CONVENTION, func, __VA_ARGS__) + ret_type WRAP(func)(__VA_ARGS__) #if defined(_WIN32) # define INTERCEPTOR_WINAPI(ret_type, func, ...) \ - INTERCEPTOR_EX(ret_type, __stdcall, func, __VA_ARGS__) + typedef ret_type (__stdcall *FUNC_TYPE(func))(__VA_ARGS__); \ + namespace __interception { \ + FUNC_TYPE(func) PTR_TO_REAL(func); \ + } \ + DECLARE_WRAPPER(ret_type, func, __VA_ARGS__) \ + extern "C" \ + INTERCEPTOR_ATTRIBUTE \ + ret_type __stdcall WRAP(func)(__VA_ARGS__) #endif +// ISO C++ forbids casting between pointer-to-function and pointer-to-object, +// so we use casting via an integral type __interception::uptr, +// assuming that system is POSIX-compliant. Using other hacks seem +// challenging, as we don't even pass function type to +// INTERCEPT_FUNCTION macro, only its name. +namespace __interception { +#if defined(_WIN64) +typedef unsigned long long uptr; // NOLINT +#else +typedef unsigned long uptr; // NOLINT +#endif // _WIN64 +} // namespace __interception + #define INCLUDED_FROM_INTERCEPTION_LIB #if defined(__linux__) |