[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

 #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