[Sanitizer] Intercepts flopen/flopenat

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

10057

maybe move it close to fopen?

10079

why do you need to define macro which used just one time? we use IMPL only for stuff which can be reused.
Could you please inline them as __xuname above?

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

654 ↗

(On Diff #359555)

unrelated, could you please land in a separate patch, OK without review

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

enum {
     CIMT_FILE
   } type;
   union {
     FileMetadata file;
   };
 };
 
 #if SI_POSIX
 typedef AddrHashMap<CommonInterceptorMetadata, 31051> MetadataHashMap;
 
 static MetadataHashMap *interceptor_metadata_map;
 
 UNUSED static void SetInterceptorMetadata(__sanitizer_FILE *addr,
                                           const FileMetadata &file) {
   MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr);
   CHECK(h.created());
   h->type = CommonInterceptorMetadata::CIMT_FILE;
   h->file = file;
 }
 
 UNUSED static const FileMetadata *GetInterceptorMetadata(
     __sanitizer_FILE *addr) {

 
 UNUSED static void DeleteInterceptorMetadata(void *addr) {
   MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr, true);
   CHECK(h.exists());
 }
 #endif  // SI_POSIX
 
 #if SANITIZER_INTERCEPT_STRLEN
 INTERCEPTOR(SIZE_T, strlen, const char *s) {
   // Sometimes strlen is called prior to InitializeCommonInterceptors,
   // in which case the REAL(strlen) typically used in
   // COMMON_INTERCEPTOR_ENTER will fail.  We use internal_strlen here
   // to handle that.
   if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
     return internal_strlen(s);
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strlen, s);
   SIZE_T result = REAL(strlen)(s);
   if (common_flags()->intercept_strlen)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, s, result + 1);
   return result;
 }
 #define INIT_STRLEN COMMON_INTERCEPT_FUNCTION(strlen)
 #else
 #define INIT_STRLEN
 #endif
 
 #if SANITIZER_INTERCEPT_STRNLEN
 INTERCEPTOR(SIZE_T, strnlen, const char *s, SIZE_T maxlen) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strnlen, s, maxlen);
   SIZE_T length = REAL(strnlen)(s, maxlen);
   if (common_flags()->intercept_strlen)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, s, Min(length + 1, maxlen));
   return length;
 }
 #define INIT_STRNLEN COMMON_INTERCEPT_FUNCTION(strnlen)
 #else
 #define INIT_STRNLEN
 #endif
 
 #if SANITIZER_INTERCEPT_STRNDUP
 INTERCEPTOR(char*, strndup, const char *s, uptr size) {
   void *ctx;
   COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size);
 }
 #define INIT_STRNDUP COMMON_INTERCEPT_FUNCTION(strndup)
 #else
 #define INIT_STRNDUP
 #endif // SANITIZER_INTERCEPT_STRNDUP
 

 #define INIT_FOPEN                   \
   COMMON_INTERCEPT_FUNCTION(fopen);  \
   COMMON_INTERCEPT_FUNCTION(fdopen); \
   COMMON_INTERCEPT_FUNCTION(freopen);
 #else
 #define INIT_FOPEN
 #endif
 
+#if SANITIZER_INTERCEPT_FLOPEN
+INTERCEPTOR(int, flopen, const char *path, int flags, ...) {
+  void *ctx;
+  va_list ap;
+  va_start(ap, flags);
+  u16 mode = static_cast<u16>(va_arg(ap, u32));
+  va_end(ap);
+  COMMON_INTERCEPTOR_ENTER(ctx, flopen, path, flags, mode);
+  if (path) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  }
+  return REAL(flopen)(path, flags, mode);
+}
+
+INTERCEPTOR(int, flopenat, int dirfd, const char *path, int flags, ...) {
+  void *ctx;
+  va_list ap;
+  va_start(ap, flags);
+  u16 mode = static_cast<u16>(va_arg(ap, u32));
+  va_end(ap);
+  COMMON_INTERCEPTOR_ENTER(ctx, flopen, path, flags, mode);
+  if (path) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  }
+  return REAL(flopenat)(dirfd, path, flags, mode);
+}
+
+#define INIT_FLOPEN    \
+  COMMON_INTERCEPT_FUNCTION(flopen); \
+  COMMON_INTERCEPT_FUNCTION(flopenat);
+#else
+#define INIT_FLOPEN
+#endif
+
 #if SANITIZER_INTERCEPT_FOPEN64
 INTERCEPTOR(__sanitizer_FILE *, fopen64, const char *path, const char *mode) {
   void *ctx;
   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);
   __sanitizer_FILE *res = REAL(fopen64)(path, mode);
   COMMON_INTERCEPTOR_FILE_OPEN(ctx, res, path);

 #else
 #define INIT_SIGALTSTACK
 #endif
 
 #if SANITIZER_INTERCEPT_UNAME
 INTERCEPTOR(int, uname, struct utsname *utsname) {
 #if SANITIZER_LINUX
   if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
     return internal_uname(utsname);
 #endif
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, uname, utsname);
   int res = REAL(uname)(utsname);
   if (!res)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, utsname,
                                    __sanitizer::struct_utsname_sz);
   return res;
 }
 #define INIT_UNAME COMMON_INTERCEPT_FUNCTION(uname)
 #else
 #define INIT_UNAME
 #endif
 
 #if SANITIZER_INTERCEPT___XUNAME
 // FreeBSD's <sys/utsname.h> define uname() as
 // static __inline int uname(struct utsname *name) {
 //   return __xuname(SYS_NMLN, (void*)name);
 // }
 INTERCEPTOR(int, __xuname, int size, void *utsname) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, __xuname, size, utsname);
   int res = REAL(__xuname)(size, utsname);
   if (!res)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, utsname,
                                    __sanitizer::struct_utsname_sz);
   return res;
 }
 #define INIT___XUNAME COMMON_INTERCEPT_FUNCTION(__xuname)
 #else
#endif
   INIT_BZERO;
   INIT_FTIME;
   INIT_XDR;
   INIT_XDRREC_LINUX;
   INIT_TSEARCH;
   INIT_LIBIO_INTERNALS;
   INIT_FOPEN;
   INIT_FOPEN64;
+  INIT_FLOPEN;
   INIT_OPEN_MEMSTREAM;
   INIT_OBSTACK;
   INIT_FFLUSH;
   INIT_FCLOSE;
   INIT_DLOPEN_DLCLOSE;
   INIT_GETPASS;
   INIT_TIMERFD;
   INIT_MLOCKX;

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

#define SANITIZER_INTERCEPT_QSORT \
   (SI_POSIX && !SI_IOSSIM && !SI_WATCHOS && !SI_TVOS && !SI_ANDROID)
 #define SANITIZER_INTERCEPT_QSORT_R SI_GLIBC
 // sigaltstack on i386 macOS cannot be intercepted due to setjmp()
 // calling it and assuming that it does not clobber registers.
 #define SANITIZER_INTERCEPT_SIGALTSTACK \
   (SI_POSIX && !(SANITIZER_MAC && SANITIZER_I386))
 #define SANITIZER_INTERCEPT_UNAME (SI_POSIX && !SI_FREEBSD)
 #define SANITIZER_INTERCEPT___XUNAME SI_FREEBSD
+#define SANITIZER_INTERCEPT_FLOPEN SI_FREEBSD
 
 // This macro gives a way for downstream users to override the above
 // interceptor macros irrespective of the platform they are on. They have
 // to do two things:
 // 1. Build compiler-rt with -DSANITIZER_OVERRIDE_INTERCEPTORS.
 // 2. Provide a header file named sanitizer_intercept_overriders.h in the
 //    include path for their compiler-rt build.
 // An example of an overrider for strlen interceptor that one can list in

compiler-rt/test/sanitizer_common/TestCases/FreeBSD/flopen.cc

+// RUN: %clangxx -O0 -g %s -o %t -lutil && %run %t 2>&1 | FileCheck %s
+
+#include <sys/fcntl.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <libutil.h>
+
+int main(void) {
+  char buf[256];
+  arc4random_buf(buf, sizeof(buf));
+  int fd = flopen(nullptr, 0, 0);
+  assert(fd == -1);
+  fd = flopen("/TMP", O_RDONLY, 0600);
+  assert(fd == -1);
+  int dirfd = open("/tmp", O_CLOEXEC | O_DIRECTORY);
+  assert(dirfd != -1);
+  fd = flopenat(dirfd, buf, O_RDONLY, 0666);
+  assert(fd == -1);
+  return 0;
+}