#include "sanitizer_placement_new.h"
#include "sanitizer_platform_interceptors.h"
#include "sanitizer_tls_get_addr.h"
+#include "sanitizer_forward_calls.h"
#include <stdarg.h>
if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
return internal_strlen(s);
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strlen, s);
COMMON_INTERCEPTOR_ENTER(ctx, strlen, s);
SIZE_T result = REAL(strlen)(s);
if (common_flags()->intercept_strlen)
#if SANITIZER_INTERCEPT_STRNLEN
INTERCEPTOR(SIZE_T, strnlen, const char *s, SIZE_T maxlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strnlen, s, maxlen);
COMMON_INTERCEPTOR_ENTER(ctx, strnlen, s, maxlen);
SIZE_T length = REAL(strnlen)(s, maxlen);
if (common_flags()->intercept_strlen)
#if SANITIZER_INTERCEPT_TEXTDOMAIN
INTERCEPTOR(char*, textdomain, const char *domainname) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(textdomain, domainname);
COMMON_INTERCEPTOR_ENTER(ctx, textdomain, domainname);
COMMON_INTERCEPTOR_READ_STRING(ctx, domainname, 0);
char *domain = REAL(textdomain)(domainname);
INTERCEPTOR(int, strcmp, const char *s1, const char *s2) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strcmp, s1, s2);
COMMON_INTERCEPTOR_ENTER(ctx, strcmp, s1, s2);
unsigned char c1, c2;
uptr i;
if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
return internal_strncmp(s1, s2, size);
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strncmp, s1, s2, size);
COMMON_INTERCEPTOR_ENTER(ctx, strncmp, s1, s2, size);
unsigned char c1 = 0, c2 = 0;
uptr i;
INTERCEPTOR(int, strcasecmp, const char *s1, const char *s2) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strcasecmp, s1, s2);
COMMON_INTERCEPTOR_ENTER(ctx, strcasecmp, s1, s2);
unsigned char c1 = 0, c2 = 0;
uptr i;
INTERCEPTOR(int, strncasecmp, const char *s1, const char *s2, SIZE_T n) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strncasecmp, s1, s2, n);
COMMON_INTERCEPTOR_ENTER(ctx, strncasecmp, s1, s2, n);
unsigned char c1 = 0, c2 = 0;
uptr i;
if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
return internal_strstr(s1, s2);
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strstr, s1, s2);
COMMON_INTERCEPTOR_ENTER(ctx, strstr, s1, s2);
char *r = REAL(strstr)(s1, s2);
if (common_flags()->intercept_strstr)
INTERCEPTOR(char*, strcasestr, const char *s1, const char *s2) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strcasestr, s1, s2);
COMMON_INTERCEPTOR_ENTER(ctx, strcasestr, s1, s2);
char *r = REAL(strcasestr)(s1, s2);
if (common_flags()->intercept_strstr)
INTERCEPTOR(void*, memmem, const void *s1, SIZE_T len1, const void *s2,
SIZE_T len2) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(memmem, s1, len1, s2, len2);
COMMON_INTERCEPTOR_ENTER(ctx, memmem, s1, len1, s2, len2);
void *r = REAL(memmem)(s1, len1, s2, len2);
if (common_flags()->intercept_memmem) {
#if SANITIZER_INTERCEPT_STRCHR
INTERCEPTOR(char*, strchr, const char *s, int c) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strchr, s, c);
if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
return internal_strchr(s, c);
COMMON_INTERCEPTOR_ENTER(ctx, strchr, s, c);
#if SANITIZER_INTERCEPT_STRCHRNUL
INTERCEPTOR(char*, strchrnul, const char *s, int c) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strchrnul, s, c);
COMMON_INTERCEPTOR_ENTER(ctx, strchrnul, s, c);
char *result = REAL(strchrnul)(s, c);
uptr len = result - s + 1;
#if SANITIZER_INTERCEPT_STRRCHR
INTERCEPTOR(char*, strrchr, const char *s, int c) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strrchr, s, c);
if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
return internal_strrchr(s, c);
COMMON_INTERCEPTOR_ENTER(ctx, strrchr, s, c);
#if SANITIZER_INTERCEPT_STRSPN
INTERCEPTOR(SIZE_T, strspn, const char *s1, const char *s2) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strspn, s1, s2);
COMMON_INTERCEPTOR_ENTER(ctx, strspn, s1, s2);
SIZE_T r = REAL(strspn)(s1, s2);
if (common_flags()->intercept_strspn) {
INTERCEPTOR(SIZE_T, strcspn, const char *s1, const char *s2) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strcspn, s1, s2);
COMMON_INTERCEPTOR_ENTER(ctx, strcspn, s1, s2);
SIZE_T r = REAL(strcspn)(s1, s2);
if (common_flags()->intercept_strspn) {
#if SANITIZER_INTERCEPT_STRPBRK
INTERCEPTOR(char *, strpbrk, const char *s1, const char *s2) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strpbrk, s1, s2);
COMMON_INTERCEPTOR_ENTER(ctx, strpbrk, s1, s2);
char *r = REAL(strpbrk)(s1, s2);
if (common_flags()->intercept_strpbrk) {
if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
return internal_memset(dst, v, size);
void *ctx;
+ MAYBE_FORWARD_TO_REAL(memset, dst, v, size);
COMMON_INTERCEPTOR_ENTER(ctx, memset, dst, v, size);
if (common_flags()->intercept_intrin)
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, size);
if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
return internal_memmove(dst, src, size);
void *ctx;
+ MAYBE_FORWARD_TO_REAL(memmove, dst, src, size);
COMMON_INTERCEPTOR_ENTER(ctx, memmove, dst, src, size);
if (common_flags()->intercept_intrin) {
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, size);
return internal_memmove(dst, src, size);
}
void *ctx;
+ MAYBE_FORWARD_TO_REAL(memcpy, dst, src, size);
COMMON_INTERCEPTOR_ENTER(ctx, memcpy, dst, src, size);
if (common_flags()->intercept_intrin) {
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, size);
if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
return internal_memcmp(a1, a2, size);
void *ctx;
+ MAYBE_FORWARD_TO_REAL(memcmp, a1, a2, size);
COMMON_INTERCEPTOR_ENTER(ctx, memcmp, a1, a2, size);
if (common_flags()->intercept_memcmp) {
if (common_flags()->strict_memcmp) {
if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
return internal_memchr(s, c, n);
void *ctx;
+ MAYBE_FORWARD_TO_REAL(memchr, s, c, n);
COMMON_INTERCEPTOR_ENTER(ctx, memchr, s, c, n);
#if SANITIZER_WINDOWS
void *res;
#if SANITIZER_INTERCEPT_MEMRCHR
INTERCEPTOR(void*, memrchr, const void *s, int c, SIZE_T n) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(memrchr, s, c, n);
COMMON_INTERCEPTOR_ENTER(ctx, memrchr, s, c, n);
COMMON_INTERCEPTOR_READ_RANGE(ctx, s, n);
return REAL(memrchr)(s, c, n);
#if SANITIZER_INTERCEPT_FREXP
INTERCEPTOR(double, frexp, double x, int *exp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(frexp, x, exp);
COMMON_INTERCEPTOR_ENTER(ctx, frexp, x, exp);
// Assuming frexp() always writes to |exp|.
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, exp, sizeof(*exp));
#if SANITIZER_INTERCEPT_FREXPF_FREXPL
INTERCEPTOR(float, frexpf, float x, int *exp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(frexpf, x, exp);
COMMON_INTERCEPTOR_ENTER(ctx, frexpf, x, exp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(long double, frexpl, long double x, int *exp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(frexpl, x, exp);
COMMON_INTERCEPTOR_ENTER(ctx, frexpl, x, exp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_READ
INTERCEPTOR(SSIZE_T, read, int fd, void *ptr, SIZE_T count) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(read, fd, ptr, count);
COMMON_INTERCEPTOR_ENTER(ctx, read, fd, ptr, count);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
// FIXME: under ASan the call below may write to freed memory and corrupt
INTERCEPTOR(SSIZE_T, __read_chk, int fd, void *ptr, SIZE_T count,
SIZE_T bufflen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__read_chk, fd, ptr, count, bufflen);
COMMON_INTERCEPTOR_ENTER(ctx, __read_chk, fd, ptr, count, bufflen);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
// FIXME: under ASan the call below may write to freed memory and corrupt
#if SANITIZER_INTERCEPT_PREAD
INTERCEPTOR(SSIZE_T, pread, int fd, void *ptr, SIZE_T count, OFF_T offset) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pread, fd, ptr, count, offset);
COMMON_INTERCEPTOR_ENTER(ctx, pread, fd, ptr, count, offset);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
// FIXME: under ASan the call below may write to freed memory and corrupt
INTERCEPTOR(SSIZE_T, __pread_chk, int fd, void *ptr, SIZE_T count,
OFF_T offset, SIZE_T buflen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__pread_chk, fd, ptr, count, offset, buflen);
COMMON_INTERCEPTOR_ENTER(ctx, __pread_chk, fd, ptr, count, offset, buflen);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
// FIXME: under ASan the call below may write to freed memory and corrupt
#if SANITIZER_INTERCEPT_PREAD64
INTERCEPTOR(SSIZE_T, pread64, int fd, void *ptr, SIZE_T count, OFF64_T offset) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pread64, fd, ptr, count, offset);
COMMON_INTERCEPTOR_ENTER(ctx, pread64, fd, ptr, count, offset);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
// FIXME: under ASan the call below may write to freed memory and corrupt
INTERCEPTOR(SSIZE_T, __pread64_chk, int fd, void *ptr, SIZE_T count,
OFF64_T offset, SIZE_T buflen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__pread64_chk, fd, ptr, count, offset, buflen);
COMMON_INTERCEPTOR_ENTER(ctx, __pread64_chk, fd, ptr, count, offset,
buflen);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
INTERCEPTOR_WITH_SUFFIX(SSIZE_T, readv, int fd, __sanitizer_iovec *iov,
int iovcnt) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(readv, fd, iov, iovcnt);
COMMON_INTERCEPTOR_ENTER(ctx, readv, fd, iov, iovcnt);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
SSIZE_T res = REAL(readv)(fd, iov, iovcnt);
INTERCEPTOR(SSIZE_T, preadv, int fd, __sanitizer_iovec *iov, int iovcnt,
OFF_T offset) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(preadv, fd, iov, iovcnt, offset);
COMMON_INTERCEPTOR_ENTER(ctx, preadv, fd, iov, iovcnt, offset);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
SSIZE_T res = REAL(preadv)(fd, iov, iovcnt, offset);
INTERCEPTOR(SSIZE_T, preadv64, int fd, __sanitizer_iovec *iov, int iovcnt,
OFF64_T offset) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(preadv64, fd, iov, iovcnt, offset);
COMMON_INTERCEPTOR_ENTER(ctx, preadv64, fd, iov, iovcnt, offset);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
SSIZE_T res = REAL(preadv64)(fd, iov, iovcnt, offset);
#if SANITIZER_INTERCEPT_WRITE
INTERCEPTOR(SSIZE_T, write, int fd, void *ptr, SIZE_T count) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(write, fd, ptr, count);
COMMON_INTERCEPTOR_ENTER(ctx, write, fd, ptr, count);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
#if SANITIZER_INTERCEPT_PWRITE
INTERCEPTOR(SSIZE_T, pwrite, int fd, void *ptr, SIZE_T count, OFF_T offset) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pwrite, fd, ptr, count, offset);
COMMON_INTERCEPTOR_ENTER(ctx, pwrite, fd, ptr, count, offset);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
INTERCEPTOR(SSIZE_T, pwrite64, int fd, void *ptr, OFF64_T count,
OFF64_T offset) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pwrite64, fd, ptr, count, offset);
COMMON_INTERCEPTOR_ENTER(ctx, pwrite64, fd, ptr, count, offset);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
INTERCEPTOR_WITH_SUFFIX(SSIZE_T, writev, int fd, __sanitizer_iovec *iov,
int iovcnt) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(writev, fd, iov, iovcnt);
COMMON_INTERCEPTOR_ENTER(ctx, writev, fd, iov, iovcnt);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
INTERCEPTOR(SSIZE_T, pwritev, int fd, __sanitizer_iovec *iov, int iovcnt,
OFF_T offset) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pwritev, fd, iov, iovcnt, offset);
COMMON_INTERCEPTOR_ENTER(ctx, pwritev, fd, iov, iovcnt, offset);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
INTERCEPTOR(SSIZE_T, pwritev64, int fd, __sanitizer_iovec *iov, int iovcnt,
OFF64_T offset) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pwritev64, fd, iov, iovcnt, offset);
COMMON_INTERCEPTOR_ENTER(ctx, pwritev64, fd, iov, iovcnt, offset);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
unsigned long arg3, // NOLINT
unsigned long arg4, unsigned long arg5) { // NOLINT
void *ctx;
+ MAYBE_FORWARD_TO_REAL(prctl, option, arg2, arg3, arg4, arg5);
COMMON_INTERCEPTOR_ENTER(ctx, prctl, option, arg2, arg3, arg4, arg5);
static const int PR_SET_NAME = 15;
int res = REAL(prctl(option, arg2, arg3, arg4, arg5));
#if SANITIZER_INTERCEPT_TIME
INTERCEPTOR(unsigned long, time, unsigned long *t) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(time, t);
COMMON_INTERCEPTOR_ENTER(ctx, time, t);
unsigned long local_t;
unsigned long res = REAL(time)(&local_t);
}
INTERCEPTOR(__sanitizer_tm *, localtime, unsigned long *timep) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(localtime, timep);
COMMON_INTERCEPTOR_ENTER(ctx, localtime, timep);
__sanitizer_tm *res = REAL(localtime)(timep);
if (res) {
}
INTERCEPTOR(__sanitizer_tm *, localtime_r, unsigned long *timep, void *result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(localtime_r, timep, result);
COMMON_INTERCEPTOR_ENTER(ctx, localtime_r, timep, result);
__sanitizer_tm *res = REAL(localtime_r)(timep, result);
if (res) {
}
INTERCEPTOR(__sanitizer_tm *, gmtime, unsigned long *timep) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(gmtime, timep);
COMMON_INTERCEPTOR_ENTER(ctx, gmtime, timep);
__sanitizer_tm *res = REAL(gmtime)(timep);
if (res) {
}
INTERCEPTOR(__sanitizer_tm *, gmtime_r, unsigned long *timep, void *result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(gmtime_r, timep, result);
COMMON_INTERCEPTOR_ENTER(ctx, gmtime_r, timep, result);
__sanitizer_tm *res = REAL(gmtime_r)(timep, result);
if (res) {
}
INTERCEPTOR(char *, ctime, unsigned long *timep) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ctime, timep);
COMMON_INTERCEPTOR_ENTER(ctx, ctime, timep);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(char *, ctime_r, unsigned long *timep, char *result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ctime_r, timep, result);
COMMON_INTERCEPTOR_ENTER(ctx, ctime_r, timep, result);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(char *, asctime, __sanitizer_tm *tm) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(asctime, tm);
COMMON_INTERCEPTOR_ENTER(ctx, asctime, tm);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(char *, asctime_r, __sanitizer_tm *tm, char *result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(asctime_r, tm, result);
COMMON_INTERCEPTOR_ENTER(ctx, asctime_r, tm, result);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(long, mktime, __sanitizer_tm *tm) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(mktime, tm);
COMMON_INTERCEPTOR_ENTER(ctx, mktime, tm);
COMMON_INTERCEPTOR_READ_RANGE(ctx, &tm->tm_sec, sizeof(tm->tm_sec));
COMMON_INTERCEPTOR_READ_RANGE(ctx, &tm->tm_min, sizeof(tm->tm_min));
#if SANITIZER_INTERCEPT_STRPTIME
INTERCEPTOR(char *, strptime, char *s, char *format, __sanitizer_tm *tm) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strptime, s, format, tm);
COMMON_INTERCEPTOR_ENTER(ctx, strptime, s, format, tm);
if (format)
COMMON_INTERCEPTOR_READ_RANGE(ctx, format, REAL(strlen)(format) + 1);
#define VSCANF_INTERCEPTOR_IMPL(vname, allowGnuMalloc, ...) \
{ \
void *ctx; \
+ MAYBE_FORWARD_TO_REAL(vname, __VA_ARGS__); \
COMMON_INTERCEPTOR_ENTER(ctx, vname, __VA_ARGS__); \
va_list aq; \
va_copy(aq, ap); \
#define VPRINTF_INTERCEPTOR_IMPL(vname, ...) \
{ \
+ MAYBE_FORWARD_TO_REAL(vname, __VA_ARGS__); \
VPRINTF_INTERCEPTOR_ENTER(vname, __VA_ARGS__); \
if (common_flags()->check_printf) \
printf_common(ctx, format, aq); \
// https://github.com/google/sanitizers/issues/321.
#define VSPRINTF_INTERCEPTOR_IMPL(vname, str, ...) \
{ \
+ MAYBE_FORWARD_TO_REAL(vname, str, __VA_ARGS__); \
VPRINTF_INTERCEPTOR_ENTER(vname, str, __VA_ARGS__) \
if (common_flags()->check_printf) { \
printf_common(ctx, format, aq); \
// https://github.com/google/sanitizers/issues/321.
#define VSNPRINTF_INTERCEPTOR_IMPL(vname, str, size, ...) \
{ \
+ MAYBE_FORWARD_TO_REAL(vname, str, size, __VA_ARGS__); \
VPRINTF_INTERCEPTOR_ENTER(vname, str, size, __VA_ARGS__) \
if (common_flags()->check_printf) { \
printf_common(ctx, format, aq); \
// https://github.com/google/sanitizers/issues/321.
#define VASPRINTF_INTERCEPTOR_IMPL(vname, strp, ...) \
{ \
+ MAYBE_FORWARD_TO_REAL(vname, strp, __VA_ARGS__); \
VPRINTF_INTERCEPTOR_ENTER(vname, strp, __VA_ARGS__) \
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, strp, sizeof(char *)); \
if (common_flags()->check_printf) { \
va_start(ap, request);
void *arg = va_arg(ap, void *);
va_end(ap);
+ MAYBE_FORWARD_TO_REAL(ioctl, d, request, arg);
COMMON_INTERCEPTOR_ENTER(ctx, ioctl, d, request, arg);
CHECK(ioctl_initialized);
#if SANITIZER_INTERCEPT_GETPWNAM_AND_FRIENDS
INTERCEPTOR(__sanitizer_passwd *, getpwnam, const char *name) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getpwnam, name);
COMMON_INTERCEPTOR_ENTER(ctx, getpwnam, name);
COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
__sanitizer_passwd *res = REAL(getpwnam)(name);
}
INTERCEPTOR(__sanitizer_passwd *, getpwuid, u32 uid) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getpwuid, uid);
COMMON_INTERCEPTOR_ENTER(ctx, getpwuid, uid);
__sanitizer_passwd *res = REAL(getpwuid)(uid);
if (res) unpoison_passwd(ctx, res);
}
INTERCEPTOR(__sanitizer_group *, getgrnam, const char *name) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getgrnam, name);
COMMON_INTERCEPTOR_ENTER(ctx, getgrnam, name);
COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
__sanitizer_group *res = REAL(getgrnam)(name);
}
INTERCEPTOR(__sanitizer_group *, getgrgid, u32 gid) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getgrgid, gid);
COMMON_INTERCEPTOR_ENTER(ctx, getgrgid, gid);
__sanitizer_group *res = REAL(getgrgid)(gid);
if (res) unpoison_group(ctx, res);
INTERCEPTOR(int, getpwnam_r, const char *name, __sanitizer_passwd *pwd,
char *buf, SIZE_T buflen, __sanitizer_passwd **result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getpwnam_r, name, pwd, buf, buflen, result);
COMMON_INTERCEPTOR_ENTER(ctx, getpwnam_r, name, pwd, buf, buflen, result);
COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
INTERCEPTOR(int, getpwuid_r, u32 uid, __sanitizer_passwd *pwd, char *buf,
SIZE_T buflen, __sanitizer_passwd **result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getpwuid_r, uid, pwd, buf, buflen, result);
COMMON_INTERCEPTOR_ENTER(ctx, getpwuid_r, uid, pwd, buf, buflen, result);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(int, getgrnam_r, const char *name, __sanitizer_group *grp,
char *buf, SIZE_T buflen, __sanitizer_group **result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getgrnam_r, name, grp, buf, buflen, result);
COMMON_INTERCEPTOR_ENTER(ctx, getgrnam_r, name, grp, buf, buflen, result);
COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
INTERCEPTOR(int, getgrgid_r, u32 gid, __sanitizer_group *grp, char *buf,
SIZE_T buflen, __sanitizer_group **result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getgrgid_r, gid, grp, buf, buflen, result);
COMMON_INTERCEPTOR_ENTER(ctx, getgrgid_r, gid, grp, buf, buflen, result);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_GETPWENT
INTERCEPTOR(__sanitizer_passwd *, getpwent, int dummy) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getpwent, dummy);
COMMON_INTERCEPTOR_ENTER(ctx, getpwent, dummy);
__sanitizer_passwd *res = REAL(getpwent)(dummy);
if (res) unpoison_passwd(ctx, res);
}
INTERCEPTOR(__sanitizer_group *, getgrent, int dummy) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getgrent, dummy);
COMMON_INTERCEPTOR_ENTER(ctx, getgrent, dummy);
__sanitizer_group *res = REAL(getgrent)(dummy);
if (res) unpoison_group(ctx, res);;
#if SANITIZER_INTERCEPT_FGETPWENT
INTERCEPTOR(__sanitizer_passwd *, fgetpwent, void *fp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fgetpwent, fp);
COMMON_INTERCEPTOR_ENTER(ctx, fgetpwent, fp);
__sanitizer_passwd *res = REAL(fgetpwent)(fp);
if (res) unpoison_passwd(ctx, res);
}
INTERCEPTOR(__sanitizer_group *, fgetgrent, void *fp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fgetgrent, fp);
COMMON_INTERCEPTOR_ENTER(ctx, fgetgrent, fp);
__sanitizer_group *res = REAL(fgetgrent)(fp);
if (res) unpoison_group(ctx, res);
INTERCEPTOR(int, getpwent_r, __sanitizer_passwd *pwbuf, char *buf,
SIZE_T buflen, __sanitizer_passwd **pwbufp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getpwent_r, pwbuf, buf, buflen, pwbufp);
COMMON_INTERCEPTOR_ENTER(ctx, getpwent_r, pwbuf, buf, buflen, pwbufp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(int, fgetpwent_r, void *fp, __sanitizer_passwd *pwbuf, char *buf,
SIZE_T buflen, __sanitizer_passwd **pwbufp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fgetpwent_r, fp, pwbuf, buf, buflen, pwbufp);
COMMON_INTERCEPTOR_ENTER(ctx, fgetpwent_r, fp, pwbuf, buf, buflen, pwbufp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(int, getgrent_r, __sanitizer_group *pwbuf, char *buf, SIZE_T buflen,
__sanitizer_group **pwbufp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getgrent_r, pwbuf, buf, buflen, pwbufp);
COMMON_INTERCEPTOR_ENTER(ctx, getgrent_r, pwbuf, buf, buflen, pwbufp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(int, fgetgrent_r, void *fp, __sanitizer_group *pwbuf, char *buf,
SIZE_T buflen, __sanitizer_group **pwbufp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fgetgrent_r, fp, pwbuf, buf, buflen, pwbufp);
COMMON_INTERCEPTOR_ENTER(ctx, fgetgrent_r, fp, pwbuf, buf, buflen, pwbufp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
// them, and we don't want things like strlen() to trigger.
INTERCEPTOR(void, setpwent, int dummy) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(setpwent, dummy);
COMMON_INTERCEPTOR_ENTER(ctx, setpwent, dummy);
REAL(setpwent)(dummy);
}
INTERCEPTOR(void, endpwent, int dummy) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(endpwent, dummy);
COMMON_INTERCEPTOR_ENTER(ctx, endpwent, dummy);
REAL(endpwent)(dummy);
}
INTERCEPTOR(void, setgrent, int dummy) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(setgrent, dummy);
COMMON_INTERCEPTOR_ENTER(ctx, setgrent, dummy);
REAL(setgrent)(dummy);
}
INTERCEPTOR(void, endgrent, int dummy) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(endgrent, dummy);
COMMON_INTERCEPTOR_ENTER(ctx, endgrent, dummy);
REAL(endgrent)(dummy);
}
#if SANITIZER_INTERCEPT_CLOCK_GETTIME
INTERCEPTOR(int, clock_getres, u32 clk_id, void *tp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(clock_getres, clk_id, tp);
COMMON_INTERCEPTOR_ENTER(ctx, clock_getres, clk_id, tp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(int, clock_gettime, u32 clk_id, void *tp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(clock_gettime, clk_id, tp);
COMMON_INTERCEPTOR_ENTER(ctx, clock_gettime, clk_id, tp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(int, clock_settime, u32 clk_id, const void *tp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(clock_settime, clk_id, tp);
COMMON_INTERCEPTOR_ENTER(ctx, clock_settime, clk_id, tp);
COMMON_INTERCEPTOR_READ_RANGE(ctx, tp, struct_timespec_sz);
return REAL(clock_settime)(clk_id, tp);
#if SANITIZER_INTERCEPT_GETITIMER
INTERCEPTOR(int, getitimer, int which, void *curr_value) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getitimer, which, curr_value);
COMMON_INTERCEPTOR_ENTER(ctx, getitimer, which, curr_value);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(int, setitimer, int which, const void *new_value, void *old_value) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(setitimer, which, new_value, old_value);
COMMON_INTERCEPTOR_ENTER(ctx, setitimer, which, new_value, old_value);
if (new_value)
COMMON_INTERCEPTOR_READ_RANGE(ctx, new_value, struct_itimerval_sz);
int (*errfunc)(const char *epath, int eerrno),
__sanitizer_glob_t *pglob) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(glob, pattern, flags, errfunc, pglob);
COMMON_INTERCEPTOR_ENTER(ctx, glob, pattern, flags, errfunc, pglob);
COMMON_INTERCEPTOR_READ_STRING(ctx, pattern, 0);
__sanitizer_glob_t glob_copy;
int (*errfunc)(const char *epath, int eerrno),
__sanitizer_glob_t *pglob) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(glob64, pattern, flags, errfunc, pglob);
COMMON_INTERCEPTOR_ENTER(ctx, glob64, pattern, flags, errfunc, pglob);
COMMON_INTERCEPTOR_READ_STRING(ctx, pattern, 0);
__sanitizer_glob_t glob_copy;
// details.
INTERCEPTOR_WITH_SUFFIX(int, wait, int *status) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(wait, status);
COMMON_INTERCEPTOR_ENTER(ctx, wait, status);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
int options) {
#endif
void *ctx;
+ MAYBE_FORWARD_TO_REAL(waitid, idtype, id, infop, options);
COMMON_INTERCEPTOR_ENTER(ctx, waitid, idtype, id, infop, options);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR_WITH_SUFFIX(int, waitpid, int pid, int *status, int options) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(waitpid, pid, status, options);
COMMON_INTERCEPTOR_ENTER(ctx, waitpid, pid, status, options);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(int, wait3, int *status, int options, void *rusage) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(wait3, status, options, rusage);
COMMON_INTERCEPTOR_ENTER(ctx, wait3, status, options, rusage);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_ANDROID
INTERCEPTOR(int, __wait4, int pid, int *status, int options, void *rusage) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__wait4, pid, status, options, rusage);
COMMON_INTERCEPTOR_ENTER(ctx, __wait4, pid, status, options, rusage);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#else
INTERCEPTOR(int, wait4, int pid, int *status, int options, void *rusage) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(wait4, pid, status, options, rusage);
COMMON_INTERCEPTOR_ENTER(ctx, wait4, pid, status, options, rusage);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_INET
INTERCEPTOR(char *, inet_ntop, int af, const void *src, char *dst, u32 size) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(inet_ntop, af, src, dst, size);
COMMON_INTERCEPTOR_ENTER(ctx, inet_ntop, af, src, dst, size);
uptr sz = __sanitizer_in_addr_sz(af);
if (sz) COMMON_INTERCEPTOR_READ_RANGE(ctx, src, sz);
}
INTERCEPTOR(int, inet_pton, int af, const char *src, void *dst) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(inet_pton, af, src, dst);
COMMON_INTERCEPTOR_ENTER(ctx, inet_pton, af, src, dst);
COMMON_INTERCEPTOR_READ_STRING(ctx, src, 0);
// FIXME: figure out read size based on the address family.
#if SANITIZER_INTERCEPT_INET
INTERCEPTOR(int, inet_aton, const char *cp, void *dst) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(inet_aton, cp, dst);
COMMON_INTERCEPTOR_ENTER(ctx, inet_aton, cp, dst);
if (cp) COMMON_INTERCEPTOR_READ_RANGE(ctx, cp, REAL(strlen)(cp) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
#if SANITIZER_INTERCEPT_PTHREAD_GETSCHEDPARAM
INTERCEPTOR(int, pthread_getschedparam, uptr thread, int *policy, int *param) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pthread_getschedparam, thread, policy, param);
COMMON_INTERCEPTOR_ENTER(ctx, pthread_getschedparam, thread, policy, param);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
struct __sanitizer_addrinfo *hints,
struct __sanitizer_addrinfo **out) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getaddrinfo, node, service, hints, out);
COMMON_INTERCEPTOR_ENTER(ctx, getaddrinfo, node, service, hints, out);
if (node) COMMON_INTERCEPTOR_READ_RANGE(ctx, node, REAL(strlen)(node) + 1);
if (service)
INTERCEPTOR(int, getnameinfo, void *sockaddr, unsigned salen, char *host,
unsigned hostlen, char *serv, unsigned servlen, int flags) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getnameinfo, sockaddr, salen, host, hostlen,
+ serv, servlen, flags);
COMMON_INTERCEPTOR_ENTER(ctx, getnameinfo, sockaddr, salen, host, hostlen,
serv, servlen, flags);
// FIXME: consider adding READ_RANGE(sockaddr, salen)
#if SANITIZER_INTERCEPT_GETSOCKNAME
INTERCEPTOR(int, getsockname, int sock_fd, void *addr, int *addrlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getsockname, sock_fd, addr, addrlen);
COMMON_INTERCEPTOR_ENTER(ctx, getsockname, sock_fd, addr, addrlen);
COMMON_INTERCEPTOR_READ_RANGE(ctx, addrlen, sizeof(*addrlen));
int addrlen_in = *addrlen;
#if SANITIZER_INTERCEPT_GETHOSTBYNAME
INTERCEPTOR(struct __sanitizer_hostent *, gethostbyname, char *name) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(gethostbyname, name);
COMMON_INTERCEPTOR_ENTER(ctx, gethostbyname, name);
struct __sanitizer_hostent *res = REAL(gethostbyname)(name);
if (res) write_hostent(ctx, res);
INTERCEPTOR(struct __sanitizer_hostent *, gethostbyaddr, void *addr, int len,
int type) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(gethostbyaddr, addr, len, type);
COMMON_INTERCEPTOR_ENTER(ctx, gethostbyaddr, addr, len, type);
COMMON_INTERCEPTOR_READ_RANGE(ctx, addr, len);
struct __sanitizer_hostent *res = REAL(gethostbyaddr)(addr, len, type);
INTERCEPTOR(struct __sanitizer_hostent *, gethostent, int fake) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(gethostent, fake);
COMMON_INTERCEPTOR_ENTER(ctx, gethostent, fake);
struct __sanitizer_hostent *res = REAL(gethostent)(fake);
if (res) write_hostent(ctx, res);
INTERCEPTOR(struct __sanitizer_hostent *, gethostbyname2, char *name, int af) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(gethostbyname2, name, af);
COMMON_INTERCEPTOR_ENTER(ctx, gethostbyname2, name, af);
struct __sanitizer_hostent *res = REAL(gethostbyname2)(name, af);
if (res) write_hostent(ctx, res);
char *buf, SIZE_T buflen, __sanitizer_hostent **result,
int *h_errnop) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(gethostbyname_r, name, ret, buf, buflen, result,
+ h_errnop);
COMMON_INTERCEPTOR_ENTER(ctx, gethostbyname_r, name, ret, buf, buflen, result,
h_errnop);
// FIXME: under ASan the call below may write to freed memory and corrupt
INTERCEPTOR(int, gethostent_r, struct __sanitizer_hostent *ret, char *buf,
SIZE_T buflen, __sanitizer_hostent **result, int *h_errnop) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(gethostent_r, ret, buf, buflen, result, h_errnop);
COMMON_INTERCEPTOR_ENTER(ctx, gethostent_r, ret, buf, buflen, result,
h_errnop);
// FIXME: under ASan the call below may write to freed memory and corrupt
struct __sanitizer_hostent *ret, char *buf, SIZE_T buflen,
__sanitizer_hostent **result, int *h_errnop) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(gethostbyaddr_r, addr, len, type, ret, buf, buflen,
+ result, h_errnop);
COMMON_INTERCEPTOR_ENTER(ctx, gethostbyaddr_r, addr, len, type, ret, buf,
buflen, result, h_errnop);
COMMON_INTERCEPTOR_READ_RANGE(ctx, addr, len);
struct __sanitizer_hostent *ret, char *buf, SIZE_T buflen,
__sanitizer_hostent **result, int *h_errnop) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(gethostbyname2_r, name, af, ret, buf, buflen,
+ result, h_errnop);
COMMON_INTERCEPTOR_ENTER(ctx, gethostbyname2_r, name, af, ret, buf, buflen,
result, h_errnop);
// FIXME: under ASan the call below may write to freed memory and corrupt
INTERCEPTOR(int, getsockopt, int sockfd, int level, int optname, void *optval,
int *optlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getsockopt, sockfd, level, optname, optval, optlen);
COMMON_INTERCEPTOR_ENTER(ctx, getsockopt, sockfd, level, optname, optval,
optlen);
if (optlen) COMMON_INTERCEPTOR_READ_RANGE(ctx, optlen, sizeof(*optlen));
#if SANITIZER_INTERCEPT_ACCEPT
INTERCEPTOR(int, accept, int fd, void *addr, unsigned *addrlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(accept, fd, addr, addrlen);
COMMON_INTERCEPTOR_ENTER(ctx, accept, fd, addr, addrlen);
unsigned addrlen0 = 0;
if (addrlen) {
#if SANITIZER_INTERCEPT_ACCEPT4
INTERCEPTOR(int, accept4, int fd, void *addr, unsigned *addrlen, int f) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(accept4, fd, addr, addrlen, f);
COMMON_INTERCEPTOR_ENTER(ctx, accept4, fd, addr, addrlen, f);
unsigned addrlen0 = 0;
if (addrlen) {
#if SANITIZER_INTERCEPT_MODF
INTERCEPTOR(double, modf, double x, double *iptr) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(modf, x, iptr);
COMMON_INTERCEPTOR_ENTER(ctx, modf, x, iptr);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(float, modff, float x, float *iptr) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(modff, x, iptr);
COMMON_INTERCEPTOR_ENTER(ctx, modff, x, iptr);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(long double, modfl, long double x, long double *iptr) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(modfl, x, iptr);
COMMON_INTERCEPTOR_ENTER(ctx, modfl, x, iptr);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(SSIZE_T, recvmsg, int fd, struct __sanitizer_msghdr *msg,
int flags) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(recvmsg, fd, msg, flags);
COMMON_INTERCEPTOR_ENTER(ctx, recvmsg, fd, msg, flags);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(SSIZE_T, sendmsg, int fd, struct __sanitizer_msghdr *msg,
int flags) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sendmsg, fd, msg, flags);
COMMON_INTERCEPTOR_ENTER(ctx, sendmsg, fd, msg, flags);
if (fd >= 0) {
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
#if SANITIZER_INTERCEPT_GETPEERNAME
INTERCEPTOR(int, getpeername, int sockfd, void *addr, unsigned *addrlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getpeername, sockfd, addr, addrlen);
COMMON_INTERCEPTOR_ENTER(ctx, getpeername, sockfd, addr, addrlen);
unsigned addr_sz;
if (addrlen) addr_sz = *addrlen;
#if SANITIZER_INTERCEPT_SYSINFO
INTERCEPTOR(int, sysinfo, void *info) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sysinfo, info);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
// https://github.com/google/sanitizers/issues/321.
#if SANITIZER_INTERCEPT_READDIR
INTERCEPTOR(__sanitizer_dirent *, opendir, const char *path) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(opendir, path);
COMMON_INTERCEPTOR_ENTER(ctx, opendir, path);
COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
__sanitizer_dirent *res = REAL(opendir)(path);
INTERCEPTOR(__sanitizer_dirent *, readdir, void *dirp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(readdir, dirp);
COMMON_INTERCEPTOR_ENTER(ctx, readdir, dirp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(int, readdir_r, void *dirp, __sanitizer_dirent *entry,
__sanitizer_dirent **result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(readdir_r, dirp, entry, result);
COMMON_INTERCEPTOR_ENTER(ctx, readdir_r, dirp, entry, result);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_READDIR64
INTERCEPTOR(__sanitizer_dirent64 *, readdir64, void *dirp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(readdir64, dirp);
COMMON_INTERCEPTOR_ENTER(ctx, readdir64, dirp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(int, readdir64_r, void *dirp, __sanitizer_dirent64 *entry,
__sanitizer_dirent64 **result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(readdir64_r, dirp, entry, result);
COMMON_INTERCEPTOR_ENTER(ctx, readdir64_r, dirp, entry, result);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_PTRACE
INTERCEPTOR(uptr, ptrace, int request, int pid, void *addr, void *data) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ptrace, request, pid, addr, data);
COMMON_INTERCEPTOR_ENTER(ctx, ptrace, request, pid, addr, data);
__sanitizer_iovec local_iovec;
#if SANITIZER_INTERCEPT_SETLOCALE
INTERCEPTOR(char *, setlocale, int category, char *locale) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(setlocale, category, locale);
COMMON_INTERCEPTOR_ENTER(ctx, setlocale, category, locale);
if (locale)
COMMON_INTERCEPTOR_READ_RANGE(ctx, locale, REAL(strlen)(locale) + 1);
#if SANITIZER_INTERCEPT_GETCWD
INTERCEPTOR(char *, getcwd, char *buf, SIZE_T size) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getcwd, buf, size);
COMMON_INTERCEPTOR_ENTER(ctx, getcwd, buf, size);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_FORTIFY_SOURCE
INTERCEPTOR(char *, __getcwd_chk, char *buf, SIZE_T size, SIZE_T buflen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__getcwd_chk, buf, size, buflen);
COMMON_INTERCEPTOR_ENTER(ctx, __getcwd_chk, buf, size, buflen);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_GET_CURRENT_DIR_NAME
INTERCEPTOR(char *, get_current_dir_name, int fake) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(get_current_dir_name, fake);
COMMON_INTERCEPTOR_ENTER(ctx, get_current_dir_name, fake);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_STRTOIMAX
INTERCEPTOR(INTMAX_T, strtoimax, const char *nptr, char **endptr, int base) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strtoimax, nptr, endptr, base);
COMMON_INTERCEPTOR_ENTER(ctx, strtoimax, nptr, endptr, base);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(INTMAX_T, strtoumax, const char *nptr, char **endptr, int base) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strtoumax, nptr, endptr, base);
COMMON_INTERCEPTOR_ENTER(ctx, strtoumax, nptr, endptr, base);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_MBSTOWCS
INTERCEPTOR(SIZE_T, mbstowcs, wchar_t *dest, const char *src, SIZE_T len) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(mbstowcs, dest, src, len);
COMMON_INTERCEPTOR_ENTER(ctx, mbstowcs, dest, src, len);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(SIZE_T, mbsrtowcs, wchar_t *dest, const char **src, SIZE_T len,
void *ps) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(mbsrtowcs, dest, src, len, ps);
COMMON_INTERCEPTOR_ENTER(ctx, mbsrtowcs, dest, src, len, ps);
if (src) COMMON_INTERCEPTOR_READ_RANGE(ctx, src, sizeof(*src));
if (ps) COMMON_INTERCEPTOR_READ_RANGE(ctx, ps, mbstate_t_sz);
INTERCEPTOR(SIZE_T, __mbstowcs_chk, wchar_t *dest, const char *src,
SIZE_T len, SIZE_T destlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__mbstowcs_chk, dest, src, len, destlen);
COMMON_INTERCEPTOR_ENTER(ctx, __mbstowcs_chk, dest, src, len, destlen);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(SIZE_T, __mbsrtowcs_chk, wchar_t *dest, const char **src,
SIZE_T len, void *ps, SIZE_T destlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__mbsrtowcs_chk, dest, src, len, ps, destlen);
COMMON_INTERCEPTOR_ENTER(ctx, __mbsrtowcs_chk, dest, src, len, ps, destlen);
if (src) COMMON_INTERCEPTOR_READ_RANGE(ctx, src, sizeof(*src));
if (ps) COMMON_INTERCEPTOR_READ_RANGE(ctx, ps, mbstate_t_sz);
INTERCEPTOR(SIZE_T, mbsnrtowcs, wchar_t *dest, const char **src, SIZE_T nms,
SIZE_T len, void *ps) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(mbsnrtowcs, dest, src, nms, len, ps);
COMMON_INTERCEPTOR_ENTER(ctx, mbsnrtowcs, dest, src, nms, len, ps);
if (src) {
COMMON_INTERCEPTOR_READ_RANGE(ctx, src, sizeof(*src));
INTERCEPTOR(SIZE_T, __mbsnrtowcs_chk, wchar_t *dest, const char **src,
SIZE_T nms, SIZE_T len, void *ps, SIZE_T destlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__mbsnrtowcs_chk, dest, src, nms, len, ps, destlen);
COMMON_INTERCEPTOR_ENTER(ctx, __mbsnrtowcs_chk, dest, src, nms, len, ps,
destlen);
if (src) {
#if SANITIZER_INTERCEPT_WCSTOMBS
INTERCEPTOR(SIZE_T, wcstombs, char *dest, const wchar_t *src, SIZE_T len) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(wcstombs, dest, src, len);
COMMON_INTERCEPTOR_ENTER(ctx, wcstombs, dest, src, len);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(SIZE_T, wcsrtombs, char *dest, const wchar_t **src, SIZE_T len,
void *ps) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(wcsrtombs, dest, src, len, ps);
COMMON_INTERCEPTOR_ENTER(ctx, wcsrtombs, dest, src, len, ps);
if (src) COMMON_INTERCEPTOR_READ_RANGE(ctx, src, sizeof(*src));
if (ps) COMMON_INTERCEPTOR_READ_RANGE(ctx, ps, mbstate_t_sz);
INTERCEPTOR(SIZE_T, __wcstombs_chk, char *dest, const wchar_t *src,
SIZE_T len, SIZE_T destlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__wcstombs_chk, dest, src, len, destlen);
COMMON_INTERCEPTOR_ENTER(ctx, __wcstombs_chk, dest, src, len, destlen);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(SIZE_T, __wcsrtombs_chk, char *dest, const wchar_t **src,
SIZE_T len, void *ps, SIZE_T destlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__wcsrtombs_chk, dest, src, len, ps, destlen);
COMMON_INTERCEPTOR_ENTER(ctx, __wcsrtombs_chk, dest, src, len, ps,
destlen);
if (src) COMMON_INTERCEPTOR_READ_RANGE(ctx, src, sizeof(*src));
INTERCEPTOR(SIZE_T, wcsnrtombs, char *dest, const wchar_t **src, SIZE_T nms,
SIZE_T len, void *ps) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(wcsnrtombs, dest, src, nms, len, ps);
COMMON_INTERCEPTOR_ENTER(ctx, wcsnrtombs, dest, src, nms, len, ps);
if (src) {
COMMON_INTERCEPTOR_READ_RANGE(ctx, src, sizeof(*src));
INTERCEPTOR(SIZE_T, __wcsnrtombs_chk, char *dest, const wchar_t **src,
SIZE_T nms, SIZE_T len, void *ps, SIZE_T destlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__wcsnrtombs_chk, dest, src, nms, len, ps, destlen);
COMMON_INTERCEPTOR_ENTER(ctx, __wcsnrtombs_chk, dest, src, nms, len, ps,
destlen);
if (src) {
#if SANITIZER_INTERCEPT_WCRTOMB
INTERCEPTOR(SIZE_T, wcrtomb, char *dest, wchar_t src, void *ps) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(wcrtomb, dest, src, ps);
COMMON_INTERCEPTOR_ENTER(ctx, wcrtomb, dest, src, ps);
if (ps) COMMON_INTERCEPTOR_READ_RANGE(ctx, ps, mbstate_t_sz);
// FIXME: under ASan the call below may write to freed memory and corrupt
INTERCEPTOR(SIZE_T, __wcrtomb_chk, char *dest, wchar_t src, void *ps,
SIZE_T destlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__wcrtomb_chk, dest, src, ps, destlen);
COMMON_INTERCEPTOR_ENTER(ctx, __wcrtomb_chk, dest, src, ps, destlen);
if (ps) COMMON_INTERCEPTOR_READ_RANGE(ctx, ps, mbstate_t_sz);
// FIXME: under ASan the call below may write to freed memory and corrupt
#if SANITIZER_INTERCEPT_TCGETATTR
INTERCEPTOR(int, tcgetattr, int fd, void *termios_p) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(tcgetattr, fd, termios_p);
COMMON_INTERCEPTOR_ENTER(ctx, tcgetattr, fd, termios_p);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_CANONICALIZE_FILE_NAME
INTERCEPTOR(char *, canonicalize_file_name, const char *path) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(canonicalize_file_name, path);
COMMON_INTERCEPTOR_ENTER(ctx, canonicalize_file_name, path);
if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
char *res = REAL(canonicalize_file_name)(path);
#if SANITIZER_INTERCEPT_CONFSTR
INTERCEPTOR(SIZE_T, confstr, int name, char *buf, SIZE_T len) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(confstr, name, buf, len);
COMMON_INTERCEPTOR_ENTER(ctx, confstr, name, buf, len);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(SIZE_T, __confstr_chk, int name, char *buf, SIZE_T len,
SIZE_T bufflen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__confstr_chk, name, buf, len, bufflen);
COMMON_INTERCEPTOR_ENTER(ctx, __confstr_chk, name, buf, len, bufflen);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_SCHED_GETAFFINITY
INTERCEPTOR(int, sched_getaffinity, int pid, SIZE_T cpusetsize, void *mask) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sched_getaffinity, pid, cpusetsize, mask);
COMMON_INTERCEPTOR_ENTER(ctx, sched_getaffinity, pid, cpusetsize, mask);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_SCHED_GETPARAM
INTERCEPTOR(int, sched_getparam, int pid, void *param) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sched_getparam, pid, param);
COMMON_INTERCEPTOR_ENTER(ctx, sched_getparam, pid, param);
int res = REAL(sched_getparam)(pid, param);
if (!res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, param, struct_sched_param_sz);
#if SANITIZER_INTERCEPT_STRERROR
INTERCEPTOR(char *, strerror, int errnum) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strerror, errnum);
COMMON_INTERCEPTOR_ENTER(ctx, strerror, errnum);
char *res = REAL(strerror)(errnum);
if (res) COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
#if SANITIZER_INTERCEPT_STRERROR_R
INTERCEPTOR(char *, strerror_r, int errnum, char *buf, SIZE_T buflen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(strerror_r, errnum, buf, buflen);
COMMON_INTERCEPTOR_ENTER(ctx, strerror_r, errnum, buf, buflen);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_XPG_STRERROR_R
INTERCEPTOR(int, __xpg_strerror_r, int errnum, char *buf, SIZE_T buflen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__xpg_strerror_r, errnum, buf, buflen);
COMMON_INTERCEPTOR_ENTER(ctx, __xpg_strerror_r, errnum, buf, buflen);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(int, scandir, char *dirp, __sanitizer_dirent ***namelist,
scandir_filter_f filter, scandir_compar_f compar) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(scandir, dirp, namelist, filter, compar);
COMMON_INTERCEPTOR_ENTER(ctx, scandir, dirp, namelist, filter, compar);
if (dirp) COMMON_INTERCEPTOR_READ_RANGE(ctx, dirp, REAL(strlen)(dirp) + 1);
scandir_filter = filter;
INTERCEPTOR(int, scandir64, char *dirp, __sanitizer_dirent64 ***namelist,
scandir64_filter_f filter, scandir64_compar_f compar) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(scandir64, dirp, namelist, filter, compar);
COMMON_INTERCEPTOR_ENTER(ctx, scandir64, dirp, namelist, filter, compar);
if (dirp) COMMON_INTERCEPTOR_READ_RANGE(ctx, dirp, REAL(strlen)(dirp) + 1);
scandir64_filter = filter;
#if SANITIZER_INTERCEPT_GETGROUPS
INTERCEPTOR(int, getgroups, int size, u32 *lst) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getgroups, size, lst);
COMMON_INTERCEPTOR_ENTER(ctx, getgroups, size, lst);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_FORTIFY_SOURCE
INTERCEPTOR(int, __getgroups_chk, int size, u32 *lst, SIZE_T lstsize) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__getgroups_chk, size, lst, lstsize);
COMMON_INTERCEPTOR_ENTER(ctx, __getgroups_chk, size, lst, lstsize);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(int, poll, __sanitizer_pollfd *fds, __sanitizer_nfds_t nfds,
int timeout) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(poll, fds, nfds, timeout);
COMMON_INTERCEPTOR_ENTER(ctx, poll, fds, nfds, timeout);
if (fds && nfds) read_pollfd(ctx, fds, nfds);
int res = COMMON_INTERCEPTOR_BLOCK_REAL(poll)(fds, nfds, timeout);
INTERCEPTOR(int, ppoll, __sanitizer_pollfd *fds, __sanitizer_nfds_t nfds,
void *timeout_ts, __sanitizer_sigset_t *sigmask) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ppoll, fds, nfds, timeout_ts, sigmask);
COMMON_INTERCEPTOR_ENTER(ctx, ppoll, fds, nfds, timeout_ts, sigmask);
if (fds && nfds) read_pollfd(ctx, fds, nfds);
if (timeout_ts)
INTERCEPTOR(int, __poll_chk, __sanitizer_pollfd *fds, __sanitizer_nfds_t nfds,
int timeout, SIZE_T fdslen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__poll_chk, fds, nfds, timeout, fdslen);
COMMON_INTERCEPTOR_ENTER(ctx, __poll_chk, fds, nfds, timeout, fdslen);
if (fds && nfds) read_pollfd(ctx, fds, nfds);
int res = COMMON_INTERCEPTOR_BLOCK_REAL(poll)(fds, nfds, timeout);
__sanitizer_nfds_t nfds, void *timeout_ts,
__sanitizer_sigset_t *sigmask, SIZE_T fdslen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__ppoll_chk, fds, nfds, timeout_ts, sigmask, fdslen);
COMMON_INTERCEPTOR_ENTER(ctx, __ppoll_chk, fds, nfds, timeout_ts,
sigmask, fdslen);
if (fds && nfds) read_pollfd(ctx, fds, nfds);
#if SANITIZER_INTERCEPT_WORDEXP
INTERCEPTOR(int, wordexp, char *s, __sanitizer_wordexp_t *p, int flags) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(wordexp, s, p, flags);
COMMON_INTERCEPTOR_ENTER(ctx, wordexp, s, p, flags);
if (s) COMMON_INTERCEPTOR_READ_RANGE(ctx, s, REAL(strlen)(s) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
#if SANITIZER_INTERCEPT_SIGWAIT
INTERCEPTOR(int, sigwait, __sanitizer_sigset_t *set, int *sig) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sigwait, set, sig);
COMMON_INTERCEPTOR_ENTER(ctx, sigwait, set, sig);
// FIXME: read sigset_t when all of sigemptyset, etc are intercepted
// FIXME: under ASan the call below may write to freed memory and corrupt
#if SANITIZER_INTERCEPT_SIGWAITINFO
INTERCEPTOR(int, sigwaitinfo, __sanitizer_sigset_t *set, void *info) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sigwaitinfo, set, info);
COMMON_INTERCEPTOR_ENTER(ctx, sigwaitinfo, set, info);
// FIXME: read sigset_t when all of sigemptyset, etc are intercepted
// FIXME: under ASan the call below may write to freed memory and corrupt
INTERCEPTOR(int, sigtimedwait, __sanitizer_sigset_t *set, void *info,
void *timeout) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sigtimedwait, set, info, timeout);
COMMON_INTERCEPTOR_ENTER(ctx, sigtimedwait, set, info, timeout);
if (timeout) COMMON_INTERCEPTOR_READ_RANGE(ctx, timeout, struct_timespec_sz);
// FIXME: read sigset_t when all of sigemptyset, etc are intercepted
#if SANITIZER_INTERCEPT_SIGSETOPS
INTERCEPTOR(int, sigemptyset, __sanitizer_sigset_t *set) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sigemptyset, set);
COMMON_INTERCEPTOR_ENTER(ctx, sigemptyset, set);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(int, sigfillset, __sanitizer_sigset_t *set) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sigfillset, set);
COMMON_INTERCEPTOR_ENTER(ctx, sigfillset, set);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_SIGPENDING
INTERCEPTOR(int, sigpending, __sanitizer_sigset_t *set) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sigpending, set);
COMMON_INTERCEPTOR_ENTER(ctx, sigpending, set);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(int, sigprocmask, int how, __sanitizer_sigset_t *set,
__sanitizer_sigset_t *oldset) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sigprocmask, how, set, oldset);
COMMON_INTERCEPTOR_ENTER(ctx, sigprocmask, how, set, oldset);
// FIXME: read sigset_t when all of sigemptyset, etc are intercepted
// FIXME: under ASan the call below may write to freed memory and corrupt
#if SANITIZER_INTERCEPT_BACKTRACE
INTERCEPTOR(int, backtrace, void **buffer, int size) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(backtrace, buffer, size);
COMMON_INTERCEPTOR_ENTER(ctx, backtrace, buffer, size);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(char **, backtrace_symbols, void **buffer, int size) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(backtrace_symbols, buffer, size);
COMMON_INTERCEPTOR_ENTER(ctx, backtrace_symbols, buffer, size);
if (buffer && size)
COMMON_INTERCEPTOR_READ_RANGE(ctx, buffer, size * sizeof(*buffer));
#if SANITIZER_INTERCEPT__EXIT
INTERCEPTOR(void, _exit, int status) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(_exit, status);
COMMON_INTERCEPTOR_ENTER(ctx, _exit, status);
COMMON_INTERCEPTOR_USER_CALLBACK_START();
int status1 = COMMON_INTERCEPTOR_ON_EXIT(ctx);
#if SANITIZER_INTERCEPT_PHTREAD_MUTEX
INTERCEPTOR(int, pthread_mutex_lock, void *m) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pthread_mutex_lock, m);
COMMON_INTERCEPTOR_ENTER(ctx, pthread_mutex_lock, m);
int res = REAL(pthread_mutex_lock)(m);
if (res == errno_EOWNERDEAD)
INTERCEPTOR(int, pthread_mutex_unlock, void *m) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pthread_mutex_unlock, m);
COMMON_INTERCEPTOR_ENTER(ctx, pthread_mutex_unlock, m);
COMMON_INTERCEPTOR_MUTEX_UNLOCK(ctx, m);
int res = REAL(pthread_mutex_unlock)(m);
#if SANITIZER_INTERCEPT_GETMNTENT
INTERCEPTOR(__sanitizer_mntent *, getmntent, void *fp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getmntent, fp);
COMMON_INTERCEPTOR_ENTER(ctx, getmntent, fp);
__sanitizer_mntent *res = REAL(getmntent)(fp);
if (res) write_mntent(ctx, res);
INTERCEPTOR(__sanitizer_mntent *, getmntent_r, void *fp,
__sanitizer_mntent *mntbuf, char *buf, int buflen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getmntent_r, fp, mntbuf, buf, buflen);
COMMON_INTERCEPTOR_ENTER(ctx, getmntent_r, fp, mntbuf, buf, buflen);
__sanitizer_mntent *res = REAL(getmntent_r)(fp, mntbuf, buf, buflen);
if (res) write_mntent(ctx, res);
#if SANITIZER_INTERCEPT_STATFS
INTERCEPTOR(int, statfs, char *path, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(statfs, path, buf);
COMMON_INTERCEPTOR_ENTER(ctx, statfs, path, buf);
if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
}
INTERCEPTOR(int, fstatfs, int fd, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fstatfs, fd, buf);
COMMON_INTERCEPTOR_ENTER(ctx, fstatfs, fd, buf);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_STATFS64
INTERCEPTOR(int, statfs64, char *path, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(statfs64, path, buf);
COMMON_INTERCEPTOR_ENTER(ctx, statfs64, path, buf);
if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
}
INTERCEPTOR(int, fstatfs64, int fd, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fstatfs64, fd, buf);
COMMON_INTERCEPTOR_ENTER(ctx, fstatfs64, fd, buf);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_STATVFS
INTERCEPTOR(int, statvfs, char *path, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(statvfs, path, buf);
COMMON_INTERCEPTOR_ENTER(ctx, statvfs, path, buf);
if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
}
INTERCEPTOR(int, fstatvfs, int fd, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fstatvfs, fd, buf);
COMMON_INTERCEPTOR_ENTER(ctx, fstatvfs, fd, buf);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_STATVFS64
INTERCEPTOR(int, statvfs64, char *path, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(statvfs64, path, buf);
COMMON_INTERCEPTOR_ENTER(ctx, statvfs64, path, buf);
if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
}
INTERCEPTOR(int, fstatvfs64, int fd, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fstatvfs64, fd, buf);
COMMON_INTERCEPTOR_ENTER(ctx, fstatvfs64, fd, buf);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_INITGROUPS
INTERCEPTOR(int, initgroups, char *user, u32 group) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(initgroups, user, group);
COMMON_INTERCEPTOR_ENTER(ctx, initgroups, user, group);
if (user) COMMON_INTERCEPTOR_READ_RANGE(ctx, user, REAL(strlen)(user) + 1);
int res = REAL(initgroups)(user, group);
#if SANITIZER_INTERCEPT_ETHER_NTOA_ATON
INTERCEPTOR(char *, ether_ntoa, __sanitizer_ether_addr *addr) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ether_ntoa, addr);
COMMON_INTERCEPTOR_ENTER(ctx, ether_ntoa, addr);
if (addr) COMMON_INTERCEPTOR_READ_RANGE(ctx, addr, sizeof(*addr));
char *res = REAL(ether_ntoa)(addr);
}
INTERCEPTOR(__sanitizer_ether_addr *, ether_aton, char *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ether_aton, buf);
COMMON_INTERCEPTOR_ENTER(ctx, ether_aton, buf);
if (buf) COMMON_INTERCEPTOR_READ_RANGE(ctx, buf, REAL(strlen)(buf) + 1);
__sanitizer_ether_addr *res = REAL(ether_aton)(buf);
#if SANITIZER_INTERCEPT_ETHER_HOST
INTERCEPTOR(int, ether_ntohost, char *hostname, __sanitizer_ether_addr *addr) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ether_ntohost, hostname, addr);
COMMON_INTERCEPTOR_ENTER(ctx, ether_ntohost, hostname, addr);
if (addr) COMMON_INTERCEPTOR_READ_RANGE(ctx, addr, sizeof(*addr));
// FIXME: under ASan the call below may write to freed memory and corrupt
}
INTERCEPTOR(int, ether_hostton, char *hostname, __sanitizer_ether_addr *addr) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ether_hostton, hostname, addr);
COMMON_INTERCEPTOR_ENTER(ctx, ether_hostton, hostname, addr);
if (hostname)
COMMON_INTERCEPTOR_READ_RANGE(ctx, hostname, REAL(strlen)(hostname) + 1);
INTERCEPTOR(int, ether_line, char *line, __sanitizer_ether_addr *addr,
char *hostname) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ether_line, line, addr, hostname);
COMMON_INTERCEPTOR_ENTER(ctx, ether_line, line, addr, hostname);
if (line) COMMON_INTERCEPTOR_READ_RANGE(ctx, line, REAL(strlen)(line) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
#if SANITIZER_INTERCEPT_ETHER_R
INTERCEPTOR(char *, ether_ntoa_r, __sanitizer_ether_addr *addr, char *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ether_ntoa_r, addr, buf);
COMMON_INTERCEPTOR_ENTER(ctx, ether_ntoa_r, addr, buf);
if (addr) COMMON_INTERCEPTOR_READ_RANGE(ctx, addr, sizeof(*addr));
// FIXME: under ASan the call below may write to freed memory and corrupt
INTERCEPTOR(__sanitizer_ether_addr *, ether_aton_r, char *buf,
__sanitizer_ether_addr *addr) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ether_aton_r, buf, addr);
COMMON_INTERCEPTOR_ENTER(ctx, ether_aton_r, buf, addr);
if (buf) COMMON_INTERCEPTOR_READ_RANGE(ctx, buf, REAL(strlen)(buf) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
#if SANITIZER_INTERCEPT_SHMCTL
INTERCEPTOR(int, shmctl, int shmid, int cmd, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(shmctl, shmid, cmd, buf);
COMMON_INTERCEPTOR_ENTER(ctx, shmctl, shmid, cmd, buf);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_RANDOM_R
INTERCEPTOR(int, random_r, void *buf, u32 *result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(random_r, buf, result);
COMMON_INTERCEPTOR_ENTER(ctx, random_r, buf, result);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#define INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(fn, sz) \
INTERCEPTOR(int, fn, void *attr, void *r) { \
void *ctx; \
+ MAYBE_FORWARD_TO_REAL(fn, attr, r); \
COMMON_INTERCEPTOR_ENTER(ctx, fn, attr, r); \
int res = REAL(fn)(attr, r); \
if (!res && r) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, r, sz); \
INTERCEPTOR_PTHREAD_ATTR_GET(stacksize, sizeof(SIZE_T))
INTERCEPTOR(int, pthread_attr_getstack, void *attr, void **addr, SIZE_T *size) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pthread_attr_getstack, attr, addr, size);
COMMON_INTERCEPTOR_ENTER(ctx, pthread_attr_getstack, attr, addr, size);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(int, pthread_attr_getaffinity_np, void *attr, SIZE_T cpusetsize,
void *cpuset) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pthread_attr_getaffinity_np, attr, cpusetsize, cpuset);
COMMON_INTERCEPTOR_ENTER(ctx, pthread_attr_getaffinity_np, attr, cpusetsize,
cpuset);
// FIXME: under ASan the call below may write to freed memory and corrupt
#if SANITIZER_INTERCEPT_TMPNAM
INTERCEPTOR(char *, tmpnam, char *s) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(tmpnam, s);
COMMON_INTERCEPTOR_ENTER(ctx, tmpnam, s);
char *res = REAL(tmpnam)(s);
if (res) {
#if SANITIZER_INTERCEPT_TMPNAM_R
INTERCEPTOR(char *, tmpnam_r, char *s) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(tmpnam_r, s);
COMMON_INTERCEPTOR_ENTER(ctx, tmpnam_r, s);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_TTYNAME_R
INTERCEPTOR(int, ttyname_r, int fd, char *name, SIZE_T namesize) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ttyname_r, fd, name, namesize);
COMMON_INTERCEPTOR_ENTER(ctx, ttyname_r, fd, name, namesize);
int res = REAL(ttyname_r)(fd, name, namesize);
if (res == 0)
INTERCEPTOR(int, __ttyname_r_chk, int fd, char *name, SIZE_T namesize,
SIZE_T namelen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__ttyname_r_chk, fd, name, namesize, namelen);
COMMON_INTERCEPTOR_ENTER(ctx, __ttyname_r_chk, fd, name, namesize, namelen);
int res = REAL(ttyname_r)(fd, name, namesize);
if (res == 0)
#if SANITIZER_INTERCEPT_TEMPNAM
INTERCEPTOR(char *, tempnam, char *dir, char *pfx) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(tempnam, dir, pfx);
COMMON_INTERCEPTOR_ENTER(ctx, tempnam, dir, pfx);
if (dir) COMMON_INTERCEPTOR_READ_RANGE(ctx, dir, REAL(strlen)(dir) + 1);
if (pfx) COMMON_INTERCEPTOR_READ_RANGE(ctx, pfx, REAL(strlen)(pfx) + 1);
#if SANITIZER_INTERCEPT_PTHREAD_SETNAME_NP
INTERCEPTOR(int, pthread_setname_np, uptr thread, const char *name) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pthread_setname_np, thread, name);
COMMON_INTERCEPTOR_ENTER(ctx, pthread_setname_np, thread, name);
COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name);
#if SANITIZER_INTERCEPT_SINCOS
INTERCEPTOR(void, sincos, double x, double *sin, double *cos) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sincos, x, sin, cos);
COMMON_INTERCEPTOR_ENTER(ctx, sincos, x, sin, cos);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(void, sincosf, float x, float *sin, float *cos) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sincosf, x, sin, cos);
COMMON_INTERCEPTOR_ENTER(ctx, sincosf, x, sin, cos);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(void, sincosl, long double x, long double *sin, long double *cos) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sincosl, x, sin, cos);
COMMON_INTERCEPTOR_ENTER(ctx, sincosl, x, sin, cos);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_REMQUO
INTERCEPTOR(double, remquo, double x, double y, int *quo) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(remquo, x, y, quo);
COMMON_INTERCEPTOR_ENTER(ctx, remquo, x, y, quo);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(float, remquof, float x, float y, int *quo) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(remquof, x, y, quo);
COMMON_INTERCEPTOR_ENTER(ctx, remquof, x, y, quo);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(long double, remquol, long double x, long double y, int *quo) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(remquol, x, y, quo);
COMMON_INTERCEPTOR_ENTER(ctx, remquol, x, y, quo);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
extern int signgam;
INTERCEPTOR(double, lgamma, double x) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(lgamma, x);
COMMON_INTERCEPTOR_ENTER(ctx, lgamma, x);
double res = REAL(lgamma)(x);
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, &signgam, sizeof(signgam));
}
INTERCEPTOR(float, lgammaf, float x) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(lgammaf, x);
COMMON_INTERCEPTOR_ENTER(ctx, lgammaf, x);
float res = REAL(lgammaf)(x);
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, &signgam, sizeof(signgam));
}
INTERCEPTOR(long double, lgammal, long double x) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(lgammal, x);
COMMON_INTERCEPTOR_ENTER(ctx, lgammal, x);
long double res = REAL(lgammal)(x);
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, &signgam, sizeof(signgam));
#if SANITIZER_INTERCEPT_LGAMMA_R
INTERCEPTOR(double, lgamma_r, double x, int *signp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(lgamma_r, x, signp);
COMMON_INTERCEPTOR_ENTER(ctx, lgamma_r, x, signp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(float, lgammaf_r, float x, int *signp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(lgammaf_r, x, signp);
COMMON_INTERCEPTOR_ENTER(ctx, lgammaf_r, x, signp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_LGAMMAL_R
INTERCEPTOR(long double, lgammal_r, long double x, int *signp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(lgammal_r, x, signp);
COMMON_INTERCEPTOR_ENTER(ctx, lgammal_r, x, signp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_DRAND48_R
INTERCEPTOR(int, drand48_r, void *buffer, double *result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(drand48_r, buffer, result);
COMMON_INTERCEPTOR_ENTER(ctx, drand48_r, buffer, result);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(int, lrand48_r, void *buffer, long *result) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(lrand48_r, buffer, result);
COMMON_INTERCEPTOR_ENTER(ctx, lrand48_r, buffer, result);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_RAND_R
INTERCEPTOR(int, rand_r, unsigned *seedp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(rand_r, seedp);
COMMON_INTERCEPTOR_ENTER(ctx, rand_r, seedp);
COMMON_INTERCEPTOR_READ_RANGE(ctx, seedp, sizeof(*seedp));
return REAL(rand_r)(seedp);
#if SANITIZER_INTERCEPT_GETLINE
INTERCEPTOR(SSIZE_T, getline, char **lineptr, SIZE_T *n, void *stream) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getline, lineptr, n, stream);
COMMON_INTERCEPTOR_ENTER(ctx, getline, lineptr, n, stream);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#define GETDELIM_INTERCEPTOR_IMPL(vname) \
{ \
void *ctx; \
+ MAYBE_FORWARD_TO_REAL(vname, lineptr, n, delim, stream); \
COMMON_INTERCEPTOR_ENTER(ctx, vname, lineptr, n, delim, stream); \
SSIZE_T res = REAL(vname)(lineptr, n, delim, stream); \
if (res > 0) { \
INTERCEPTOR(SIZE_T, iconv, void *cd, char **inbuf, SIZE_T *inbytesleft,
char **outbuf, SIZE_T *outbytesleft) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(iconv, cd, inbuf, inbytesleft, outbuf, outbytesleft);
COMMON_INTERCEPTOR_ENTER(ctx, iconv, cd, inbuf, inbytesleft, outbuf,
outbytesleft);
if (inbytesleft)
#if SANITIZER_INTERCEPT_TIMES
INTERCEPTOR(__sanitizer_clock_t, times, void *tms) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(times, tms);
COMMON_INTERCEPTOR_ENTER(ctx, times, tms);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
// because sanitizers use initial-exec tls model).
INTERCEPTOR(void *, __tls_get_addr, void *arg) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__tls_get_addr, arg);
COMMON_INTERCEPTOR_ENTER(ctx, __tls_get_addr, arg);
void *res = REAL(__tls_get_addr)(arg);
uptr tls_begin, tls_end;
#define INIT_TLS_GET_ADDR COMMON_INTERCEPT_FUNCTION(__tls_get_addr_internal)
INTERCEPTOR(uptr, __tls_get_addr_internal, void *arg) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__tls_get_addr_internal, arg);
COMMON_INTERCEPTOR_ENTER(ctx, __tls_get_addr_internal, arg);
uptr res = REAL(__tls_get_addr_internal)(arg);
uptr tp = reinterpret_cast<uptr>(__builtin_thread_pointer());
#if SANITIZER_INTERCEPT_LISTXATTR
INTERCEPTOR(SSIZE_T, listxattr, const char *path, char *list, SIZE_T size) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(listxattr, path, list, size);
COMMON_INTERCEPTOR_ENTER(ctx, listxattr, path, list, size);
if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
}
INTERCEPTOR(SSIZE_T, llistxattr, const char *path, char *list, SIZE_T size) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(llistxattr, path, list, size);
COMMON_INTERCEPTOR_ENTER(ctx, llistxattr, path, list, size);
if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
}
INTERCEPTOR(SSIZE_T, flistxattr, int fd, char *list, SIZE_T size) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(flistxattr, fd, list, size);
COMMON_INTERCEPTOR_ENTER(ctx, flistxattr, fd, list, size);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(SSIZE_T, getxattr, const char *path, const char *name, char *value,
SIZE_T size) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getxattr, path, name, value, size);
COMMON_INTERCEPTOR_ENTER(ctx, getxattr, path, name, value, size);
if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
if (name) COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
INTERCEPTOR(SSIZE_T, lgetxattr, const char *path, const char *name, char *value,
SIZE_T size) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(lgetxattr, path, name, value, size);
COMMON_INTERCEPTOR_ENTER(ctx, lgetxattr, path, name, value, size);
if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
if (name) COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
INTERCEPTOR(SSIZE_T, fgetxattr, int fd, const char *name, char *value,
SIZE_T size) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fgetxattr, fd, name, value, size);
COMMON_INTERCEPTOR_ENTER(ctx, fgetxattr, fd, name, value, size);
if (name) COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
// FIXME: under ASan the call below may write to freed memory and corrupt
#if SANITIZER_INTERCEPT_GETRESID
INTERCEPTOR(int, getresuid, void *ruid, void *euid, void *suid) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getresuid, ruid, euid, suid);
COMMON_INTERCEPTOR_ENTER(ctx, getresuid, ruid, euid, suid);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(int, getresgid, void *rgid, void *egid, void *sgid) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getresgid, rgid, egid, sgid);
COMMON_INTERCEPTOR_ENTER(ctx, getresgid, rgid, egid, sgid);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
// intercept it to poison the memory again.
INTERCEPTOR(int, getifaddrs, __sanitizer_ifaddrs **ifap) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getifaddrs, ifap);
COMMON_INTERCEPTOR_ENTER(ctx, getifaddrs, ifap);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#if SANITIZER_INTERCEPT_IF_INDEXTONAME
INTERCEPTOR(char *, if_indextoname, unsigned int ifindex, char* ifname) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(if_indextoname, ifindex, ifname);
COMMON_INTERCEPTOR_ENTER(ctx, if_indextoname, ifindex, ifname);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
}
INTERCEPTOR(unsigned int, if_nametoindex, const char* ifname) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(if_nametoindex, ifname);
COMMON_INTERCEPTOR_ENTER(ctx, if_nametoindex, ifname);
if (ifname)
COMMON_INTERCEPTOR_READ_RANGE(ctx, ifname, REAL(strlen)(ifname) + 1);
#if SANITIZER_INTERCEPT_CAPGET
INTERCEPTOR(int, capget, void *hdrp, void *datap) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(capget, hdrp, datap);
COMMON_INTERCEPTOR_ENTER(ctx, capget, hdrp, datap);
if (hdrp)
COMMON_INTERCEPTOR_READ_RANGE(ctx, hdrp, __user_cap_header_struct_sz);
}
INTERCEPTOR(int, capset, void *hdrp, const void *datap) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(capset, hdrp, datap);
COMMON_INTERCEPTOR_ENTER(ctx, capset, hdrp, datap);
if (hdrp)
COMMON_INTERCEPTOR_READ_RANGE(ctx, hdrp, __user_cap_header_struct_sz);
DECLARE_REAL_AND_INTERCEPTOR(void *, memset, void *, int, uptr)
INTERCEPTOR(void *, __aeabi_memmove, void *to, const void *from, uptr size) {
+ MAYBE_FORWARD_TO_REAL(__aeabi_memmove, to, from, size);
return WRAP(memmove)(to, from, size);
}
INTERCEPTOR(void *, __aeabi_memmove4, void *to, const void *from, uptr size) {
+ MAYBE_FORWARD_TO_REAL(__aeabi_memmove4, to, from, size);
return WRAP(memmove)(to, from, size);
}
INTERCEPTOR(void *, __aeabi_memmove8, void *to, const void *from, uptr size) {
+ MAYBE_FORWARD_TO_REAL(__aeabi_memmove8, to, from, size);
return WRAP(memmove)(to, from, size);
}
INTERCEPTOR(void *, __aeabi_memcpy, void *to, const void *from, uptr size) {
+ MAYBE_FORWARD_TO_REAL(__aeabi_memcpy, to, from, size);
return WRAP(memcpy)(to, from, size);
}
INTERCEPTOR(void *, __aeabi_memcpy4, void *to, const void *from, uptr size) {
+ MAYBE_FORWARD_TO_REAL(__aeabi_memcpy4, to, from, size);
return WRAP(memcpy)(to, from, size);
}
INTERCEPTOR(void *, __aeabi_memcpy8, void *to, const void *from, uptr size) {
+ MAYBE_FORWARD_TO_REAL(__aeabi_memcpy8, to, from, size);
return WRAP(memcpy)(to, from, size);
}
// Note the argument order.
INTERCEPTOR(void *, __aeabi_memset, void *block, uptr size, int c) {
+ MAYBE_FORWARD_TO_REAL(__aeabi_memset, block, size, c);
return WRAP(memset)(block, c, size);
}
INTERCEPTOR(void *, __aeabi_memset4, void *block, uptr size, int c) {
+ MAYBE_FORWARD_TO_REAL(__aeabi_memset4, block, size, c);
return WRAP(memset)(block, c, size);
}
INTERCEPTOR(void *, __aeabi_memset8, void *block, uptr size, int c) {
+ MAYBE_FORWARD_TO_REAL(__aeabi_memset8, block, size, c);
return WRAP(memset)(block, c, size);
}
INTERCEPTOR(void *, __aeabi_memclr, void *block, uptr size) {
+ MAYBE_FORWARD_TO_REAL(__aeabi_memclr, block, size);
return WRAP(memset)(block, 0, size);
}
INTERCEPTOR(void *, __aeabi_memclr4, void *block, uptr size) {
+ MAYBE_FORWARD_TO_REAL(__aeabi_memclr4, block, size);
return WRAP(memset)(block, 0, size);
}
INTERCEPTOR(void *, __aeabi_memclr8, void *block, uptr size) {
+ MAYBE_FORWARD_TO_REAL(__aeabi_memclr8, block, size);
return WRAP(memset)(block, 0, size);
}
#define INIT_AEABI_MEM \
DECLARE_REAL_AND_INTERCEPTOR(void *, memset, void *, int, uptr);
INTERCEPTOR(void *, __bzero, void *block, uptr size) {
+ MAYBE_FORWARD_TO_REAL(__bzero, block, size);
return WRAP(memset)(block, 0, size);
}
#define INIT___BZERO COMMON_INTERCEPT_FUNCTION(__bzero);
#if SANITIZER_INTERCEPT_FTIME
INTERCEPTOR(int, ftime, __sanitizer_timeb *tp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ftime, tp);
COMMON_INTERCEPTOR_ENTER(ctx, ftime, tp);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(void, xdrmem_create, __sanitizer_XDR *xdrs, uptr addr,
unsigned size, int op) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(xdrmem_create, xdrs, addr, size, op);
COMMON_INTERCEPTOR_ENTER(ctx, xdrmem_create, xdrs, addr, size, op);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(void, xdrstdio_create, __sanitizer_XDR *xdrs, void *file, int op) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(xdrstdio_create, xdrs, file, op);
COMMON_INTERCEPTOR_ENTER(ctx, xdrstdio_create, xdrs, file, op);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
#define XDR_INTERCEPTOR(F, T) \
INTERCEPTOR(int, F, __sanitizer_XDR *xdrs, T *p) { \
void *ctx; \
+ MAYBE_FORWARD_TO_REAL(F, xdrs, p); \
COMMON_INTERCEPTOR_ENTER(ctx, F, xdrs, p); \
if (p && xdrs->x_op == __sanitizer_XDR_ENCODE) \
COMMON_INTERCEPTOR_READ_RANGE(ctx, p, sizeof(*p)); \
INTERCEPTOR(int, xdr_bytes, __sanitizer_XDR *xdrs, char **p, unsigned *sizep,
unsigned maxsize) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(xdr_bytes, xdrs, p, sizep, maxsize);
COMMON_INTERCEPTOR_ENTER(ctx, xdr_bytes, xdrs, p, sizep, maxsize);
if (p && sizep && xdrs->x_op == __sanitizer_XDR_ENCODE) {
COMMON_INTERCEPTOR_READ_RANGE(ctx, p, sizeof(*p));
INTERCEPTOR(int, xdr_string, __sanitizer_XDR *xdrs, char **p,
unsigned maxsize) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(xdr_string, xdrs, p, maxsize);
COMMON_INTERCEPTOR_ENTER(ctx, xdr_string, xdrs, p, maxsize);
if (p && xdrs->x_op == __sanitizer_XDR_ENCODE) {
COMMON_INTERCEPTOR_READ_RANGE(ctx, p, sizeof(*p));
INTERCEPTOR(void *, tsearch, void *key, void **rootp,
int (*compar)(const void *, const void *)) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(tsearch, key, rootp, compar);
COMMON_INTERCEPTOR_ENTER(ctx, tsearch, key, rootp, compar);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
// These guys are called when a .c source is built with -O2.
INTERCEPTOR(int, __uflow, __sanitizer_FILE *fp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__uflow, fp);
COMMON_INTERCEPTOR_ENTER(ctx, __uflow, fp);
int res = REAL(__uflow)(fp);
unpoison_file(fp);
}
INTERCEPTOR(int, __underflow, __sanitizer_FILE *fp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__underflow, fp);
COMMON_INTERCEPTOR_ENTER(ctx, __underflow, fp);
int res = REAL(__underflow)(fp);
unpoison_file(fp);
}
INTERCEPTOR(int, __overflow, __sanitizer_FILE *fp, int ch) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__overflow, fp, ch);
COMMON_INTERCEPTOR_ENTER(ctx, __overflow, fp, ch);
int res = REAL(__overflow)(fp, ch);
unpoison_file(fp);
}
INTERCEPTOR(int, __wuflow, __sanitizer_FILE *fp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__wuflow, fp);
COMMON_INTERCEPTOR_ENTER(ctx, __wuflow, fp);
int res = REAL(__wuflow)(fp);
unpoison_file(fp);
}
INTERCEPTOR(int, __wunderflow, __sanitizer_FILE *fp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__wunderflow, fp);
COMMON_INTERCEPTOR_ENTER(ctx, __wunderflow, fp);
int res = REAL(__wunderflow)(fp);
unpoison_file(fp);
}
INTERCEPTOR(int, __woverflow, __sanitizer_FILE *fp, int ch) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__woverflow, fp, ch);
COMMON_INTERCEPTOR_ENTER(ctx, __woverflow, fp, ch);
int res = REAL(__woverflow)(fp, ch);
unpoison_file(fp);
#if SANITIZER_INTERCEPT_FOPEN
INTERCEPTOR(__sanitizer_FILE *, fopen, const char *path, const char *mode) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fopen, path, mode);
COMMON_INTERCEPTOR_ENTER(ctx, fopen, path, mode);
if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
}
INTERCEPTOR(__sanitizer_FILE *, fdopen, int fd, const char *mode) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fdopen, fd, mode);
COMMON_INTERCEPTOR_ENTER(ctx, fdopen, fd, mode);
COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
__sanitizer_FILE *res = REAL(fdopen)(fd, mode);
INTERCEPTOR(__sanitizer_FILE *, freopen, const char *path, const char *mode,
__sanitizer_FILE *fp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(freopen, path, mode, fp);
COMMON_INTERCEPTOR_ENTER(ctx, freopen, path, mode, fp);
if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
#if SANITIZER_INTERCEPT_FOPEN64
INTERCEPTOR(__sanitizer_FILE *, fopen64, const char *path, const char *mode) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fopen64, path, mode);
COMMON_INTERCEPTOR_ENTER(ctx, fopen64, path, mode);
COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
INTERCEPTOR(__sanitizer_FILE *, freopen64, const char *path, const char *mode,
__sanitizer_FILE *fp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(freopen64, path, mode, fp);
COMMON_INTERCEPTOR_ENTER(ctx, freopen64, path, mode, fp);
if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
#if SANITIZER_INTERCEPT_OPEN_MEMSTREAM
INTERCEPTOR(__sanitizer_FILE *, open_memstream, char **ptr, SIZE_T *sizeloc) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(open_memstream, ptr, sizeloc);
COMMON_INTERCEPTOR_ENTER(ctx, open_memstream, ptr, sizeloc);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
INTERCEPTOR(__sanitizer_FILE *, open_wmemstream, wchar_t **ptr,
SIZE_T *sizeloc) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(open_wmemstream, ptr, sizeloc);
COMMON_INTERCEPTOR_ENTER(ctx, open_wmemstream, ptr, sizeloc);
__sanitizer_FILE *res = REAL(open_wmemstream)(ptr, sizeloc);
if (res) {
INTERCEPTOR(__sanitizer_FILE *, fmemopen, void *buf, SIZE_T size,
const char *mode) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fmemopen, buf, size, mode);
COMMON_INTERCEPTOR_ENTER(ctx, fmemopen, buf, size, mode);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
int align, void *(*alloc_fn)(uptr arg, uptr sz),
void (*free_fn)(uptr arg, void *p)) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(_obstack_begin_1, obstack, sz, align, alloc_fn, free_fn);
COMMON_INTERCEPTOR_ENTER(ctx, _obstack_begin_1, obstack, sz, align, alloc_fn,
free_fn);
int res = REAL(_obstack_begin_1)(obstack, sz, align, alloc_fn, free_fn);
INTERCEPTOR(int, _obstack_begin, __sanitizer_obstack *obstack, int sz,
int align, void *(*alloc_fn)(uptr sz), void (*free_fn)(void *p)) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(_obstack_begin, obstack, sz, align, alloc_fn, free_fn);
COMMON_INTERCEPTOR_ENTER(ctx, _obstack_begin, obstack, sz, align, alloc_fn,
free_fn);
int res = REAL(_obstack_begin)(obstack, sz, align, alloc_fn, free_fn);
}
INTERCEPTOR(void, _obstack_newchunk, __sanitizer_obstack *obstack, int length) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(_obstack_newchunk, obstack, length);
COMMON_INTERCEPTOR_ENTER(ctx, _obstack_newchunk, obstack, length);
REAL(_obstack_newchunk)(obstack, length);
if (obstack->chunk)
#if SANITIZER_INTERCEPT_FFLUSH
INTERCEPTOR(int, fflush, __sanitizer_FILE *fp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fflush, fp);
COMMON_INTERCEPTOR_ENTER(ctx, fflush, fp);
int res = REAL(fflush)(fp);
// FIXME: handle fp == NULL
#if SANITIZER_INTERCEPT_FCLOSE
INTERCEPTOR(int, fclose, __sanitizer_FILE *fp) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fclose, fp);
COMMON_INTERCEPTOR_ENTER(ctx, fclose, fp);
COMMON_INTERCEPTOR_FILE_CLOSE(ctx, fp);
const FileMetadata *m = GetInterceptorMetadata(fp);
#if SANITIZER_INTERCEPT_DLOPEN_DLCLOSE
INTERCEPTOR(void*, dlopen, const char *filename, int flag) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(dlopen, filename, flag);
COMMON_INTERCEPTOR_ENTER_NOIGNORE(ctx, dlopen, filename, flag);
if (filename) COMMON_INTERCEPTOR_READ_STRING(ctx, filename, 0);
COMMON_INTERCEPTOR_ON_DLOPEN(filename, flag);
INTERCEPTOR(int, dlclose, void *handle) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(dlclose, handle);
COMMON_INTERCEPTOR_ENTER_NOIGNORE(ctx, dlclose, handle);
int res = REAL(dlclose)(handle);
COMMON_INTERCEPTOR_LIBRARY_UNLOADED();
#if SANITIZER_INTERCEPT_GETPASS
INTERCEPTOR(char *, getpass, const char *prompt) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(getpass, prompt);
COMMON_INTERCEPTOR_ENTER(ctx, getpass, prompt);
if (prompt)
COMMON_INTERCEPTOR_READ_RANGE(ctx, prompt, REAL(strlen)(prompt)+1);
INTERCEPTOR(int, timerfd_settime, int fd, int flags, void *new_value,
void *old_value) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(timerfd_settime, fd, flags, new_value, old_value);
COMMON_INTERCEPTOR_ENTER(ctx, timerfd_settime, fd, flags, new_value,
old_value);
COMMON_INTERCEPTOR_READ_RANGE(ctx, new_value, struct_itimerspec_sz);
INTERCEPTOR(int, timerfd_gettime, int fd, void *curr_value) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(timerfd_gettime, fd, curr_value);
COMMON_INTERCEPTOR_ENTER(ctx, timerfd_gettime, fd, curr_value);
int res = REAL(timerfd_gettime)(fd, curr_value);
if (res != -1 && curr_value)
}
INTERCEPTOR(int, mlock, const void *addr, uptr len) {
+ MAYBE_FORWARD_TO_REAL(mlock, addr, len);
MlockIsUnsupported();
return 0;
}
INTERCEPTOR(int, munlock, const void *addr, uptr len) {
+ MAYBE_FORWARD_TO_REAL(munlock, addr, len);
MlockIsUnsupported();
return 0;
}
INTERCEPTOR(int, mlockall, int flags) {
+ MAYBE_FORWARD_TO_REAL(mlockall, flags);
MlockIsUnsupported();
return 0;
}
INTERCEPTOR(int, munlockall, void) {
+ MAYBE_FORWARD_TO_REAL(munlockall,);
MlockIsUnsupported();
return 0;
}
INTERCEPTOR(__sanitizer_FILE *, fopencookie, void *cookie, const char *mode,
__sanitizer_cookie_io_functions_t io_funcs) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(fopencookie, cookie, mode, io_funcs);
COMMON_INTERCEPTOR_ENTER(ctx, fopencookie, cookie, mode, io_funcs);
WrappedCookie *wrapped_cookie =
(WrappedCookie *)InternalAlloc(sizeof(WrappedCookie));
INTERCEPTOR(int, sem_destroy, __sanitizer_sem_t *s) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sem_destroy, s);
COMMON_INTERCEPTOR_ENTER(ctx, sem_destroy, s);
int res = REAL(sem_destroy)(s);
return res;
INTERCEPTOR(int, sem_wait, __sanitizer_sem_t *s) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sem_wait, s);
COMMON_INTERCEPTOR_ENTER(ctx, sem_wait, s);
int res = COMMON_INTERCEPTOR_BLOCK_REAL(sem_wait)(s);
if (res == 0) {
INTERCEPTOR(int, sem_trywait, __sanitizer_sem_t *s) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sem_trywait, s);
COMMON_INTERCEPTOR_ENTER(ctx, sem_trywait, s);
int res = COMMON_INTERCEPTOR_BLOCK_REAL(sem_trywait)(s);
if (res == 0) {
INTERCEPTOR(int, sem_timedwait, __sanitizer_sem_t *s, void *abstime) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sem_timedwait, s, abstime);
COMMON_INTERCEPTOR_ENTER(ctx, sem_timedwait, s, abstime);
COMMON_INTERCEPTOR_READ_RANGE(ctx, abstime, struct_timespec_sz);
int res = COMMON_INTERCEPTOR_BLOCK_REAL(sem_timedwait)(s, abstime);
INTERCEPTOR(int, sem_post, __sanitizer_sem_t *s) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sem_post, s);
COMMON_INTERCEPTOR_ENTER(ctx, sem_post, s);
COMMON_INTERCEPTOR_RELEASE(ctx, (uptr)s);
int res = REAL(sem_post)(s);
INTERCEPTOR(int, sem_getvalue, __sanitizer_sem_t *s, int *sval) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sem_getvalue, s, sval);
COMMON_INTERCEPTOR_ENTER(ctx, sem_getvalue, s, sval);
int res = REAL(sem_getvalue)(s, sval);
if (res == 0) {
#if SANITIZER_INTERCEPT_PTHREAD_SETCANCEL
INTERCEPTOR(int, pthread_setcancelstate, int state, int *oldstate) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pthread_setcancelstate, state, oldstate);
COMMON_INTERCEPTOR_ENTER(ctx, pthread_setcancelstate, state, oldstate);
int res = REAL(pthread_setcancelstate)(state, oldstate);
if (res == 0)
INTERCEPTOR(int, pthread_setcanceltype, int type, int *oldtype) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(pthread_setcanceltype, type, oldtype);
COMMON_INTERCEPTOR_ENTER(ctx, pthread_setcanceltype, type, oldtype);
int res = REAL(pthread_setcanceltype)(type, oldtype);
if (res == 0)
#if SANITIZER_INTERCEPT_MINCORE
INTERCEPTOR(int, mincore, void *addr, uptr length, unsigned char *vec) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(mincore, addr, length, vec);
COMMON_INTERCEPTOR_ENTER(ctx, mincore, addr, length, vec);
int res = REAL(mincore)(addr, length, vec);
if (res == 0) {
uptr liovcnt, __sanitizer_iovec *remote_iov, uptr riovcnt,
uptr flags) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(process_vm_readv, pid, local_iov, liovcnt, remote_iov,
+ riovcnt, flags);
COMMON_INTERCEPTOR_ENTER(ctx, process_vm_readv, pid, local_iov, liovcnt,
remote_iov, riovcnt, flags);
SSIZE_T res = REAL(process_vm_readv)(pid, local_iov, liovcnt, remote_iov,
uptr liovcnt, __sanitizer_iovec *remote_iov, uptr riovcnt,
uptr flags) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(process_vm_writev, pid, local_iov, liovcnt, remote_iov,
+ riovcnt, flags);
COMMON_INTERCEPTOR_ENTER(ctx, process_vm_writev, pid, local_iov, liovcnt,
remote_iov, riovcnt, flags);
SSIZE_T res = REAL(process_vm_writev)(pid, local_iov, liovcnt, remote_iov,
#if SANITIZER_INTERCEPT_CTERMID
INTERCEPTOR(char *, ctermid, char *s) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ctermid, s);
COMMON_INTERCEPTOR_ENTER(ctx, ctermid, s);
char *res = REAL(ctermid)(s);
if (res) {
#if SANITIZER_INTERCEPT_CTERMID_R
INTERCEPTOR(char *, ctermid_r, char *s) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(ctermid_r, s);
COMMON_INTERCEPTOR_ENTER(ctx, ctermid_r, s);
char *res = REAL(ctermid_r)(s);
if (res) {
#if SANITIZER_INTERCEPT_RECV_RECVFROM
INTERCEPTOR(SSIZE_T, recv, int fd, void *buf, SIZE_T len, int flags) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(recv, fd, buf, len, flags);
COMMON_INTERCEPTOR_ENTER(ctx, recv, fd, buf, len, flags);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
SSIZE_T res = REAL(recv)(fd, buf, len, flags);
INTERCEPTOR(SSIZE_T, recvfrom, int fd, void *buf, SIZE_T len, int flags,
void *srcaddr, int *addrlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(recvfrom, fd, buf, len, flags, srcaddr, addrlen);
COMMON_INTERCEPTOR_ENTER(ctx, recvfrom, fd, buf, len, flags, srcaddr,
addrlen);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
INTERCEPTOR(SSIZE_T, __recv_chk, int fd, void *buf, SIZE_T len, SIZE_T buflen,
int flags) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__recv_chk, fd, buf, len, buflen, flags);
COMMON_INTERCEPTOR_ENTER(ctx, __recv_chk, fd, buf, len, buflen, flags);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
SSIZE_T res = REAL(recv)(fd, buf, len, flags);
INTERCEPTOR(SSIZE_T, __recvfrom_chk, int fd, void *buf, SIZE_T len,
SIZE_T buflen, int flags, void *srcaddr, int *addrlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__recvfrom_chk, fd, buf, len, buflen, flags, srcaddr,
+ addrlen);
COMMON_INTERCEPTOR_ENTER(ctx, __recvfrom_chk, fd, buf, len, buflen, flags,
srcaddr, addrlen);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
#if SANITIZER_INTERCEPT_SEND_SENDTO
INTERCEPTOR(SSIZE_T, send, int fd, void *buf, SIZE_T len, int flags) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(send, fd, buf, len, flags);
COMMON_INTERCEPTOR_ENTER(ctx, send, fd, buf, len, flags);
if (fd >= 0) {
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
INTERCEPTOR(SSIZE_T, sendto, int fd, void *buf, SIZE_T len, int flags,
void *dstaddr, int addrlen) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(sendto, fd, buf, len, flags, dstaddr, addrlen);
COMMON_INTERCEPTOR_ENTER(ctx, sendto, fd, buf, len, flags, dstaddr, addrlen);
if (fd >= 0) {
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
#if SANITIZER_INTERCEPT_EVENTFD_READ_WRITE
INTERCEPTOR(int, eventfd_read, int fd, u64 *value) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(eventfd_read, fd, value);
COMMON_INTERCEPTOR_ENTER(ctx, eventfd_read, fd, value);
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
int res = REAL(eventfd_read)(fd, value);
}
INTERCEPTOR(int, eventfd_write, int fd, u64 value) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(eventfd_write, fd, value);
COMMON_INTERCEPTOR_ENTER(ctx, eventfd_write, fd, value);
if (fd >= 0) {
COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
#if SANITIZER_INTERCEPT_STAT
INTERCEPTOR(int, stat, const char *path, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(stat, path, buf);
COMMON_INTERCEPTOR_ENTER(ctx, stat, path, buf);
if (common_flags()->intercept_stat)
COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
#if SANITIZER_INTERCEPT___XSTAT
INTERCEPTOR(int, __xstat, int version, const char *path, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__xstat, version, path, buf);
COMMON_INTERCEPTOR_ENTER(ctx, __xstat, version, path, buf);
if (common_flags()->intercept_stat)
COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
#if SANITIZER_INTERCEPT___XSTAT64
INTERCEPTOR(int, __xstat64, int version, const char *path, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__xstat64, version, path, buf);
COMMON_INTERCEPTOR_ENTER(ctx, __xstat64, version, path, buf);
if (common_flags()->intercept_stat)
COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
#if SANITIZER_INTERCEPT___LXSTAT
INTERCEPTOR(int, __lxstat, int version, const char *path, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__lxstat, version, path, buf);
COMMON_INTERCEPTOR_ENTER(ctx, __lxstat, version, path, buf);
if (common_flags()->intercept_stat)
COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
#if SANITIZER_INTERCEPT___LXSTAT64
INTERCEPTOR(int, __lxstat64, int version, const char *path, void *buf) {
void *ctx;
+ MAYBE_FORWARD_TO_REAL(__lxstat64, version, path, buf);
COMMON_INTERCEPTOR_ENTER(ctx, __lxstat64, version, path, buf);
if (common_flags()->intercept_stat)
COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
#if SANITIZER_INTERCEPT_MCHECK_MPROBE
INTERCEPTOR(int, mcheck, void (*abortfunc)(int mstatus)) {
+ MAYBE_FORWARD_TO_REAL(mcheck, abortfunc);
return 0;
}
#define INIT_MCHECK COMMON_INTERCEPT_FUNCTION(mcheck)
INTERCEPTOR(int, mcheck_pedantic, void (*abortfunc)(int mstatus)) {
+ MAYBE_FORWARD_TO_REAL(mcheck_pedantic, abortfunc);
return 0;
}
#define INIT_MCHECK_PEDANTIC COMMON_INTERCEPT_FUNCTION(mcheck_pedantic)
INTERCEPTOR(int, mprobe, void *ptr) {
+ MAYBE_FORWARD_TO_REAL(mprobe, ptr);
return 0;
}
#define INIT_MPROBE COMMON_INTERCEPT_FUNCTION(mprobe)
projects / platform / upstream / linaro-gcc.git / commitdiff