Add new interceptors for FILE repositioning stream

[krytarowski]

Summary

Add new interceptors for a set of functions to reposition a stream:
fgetpos, fseek, fseeko, fsetpos, ftell, ftello, rewind .

Add a dedicated test.

Enable this interface on NetBSD.

lib/sanitizer_common/sanitizer_common_interceptors.inc

 
 #if SANITIZER_NETBSD
 #define clock_getres __clock_getres50
 #define clock_gettime __clock_gettime50
 #define clock_settime __clock_settime50
 #define ctime __ctime50
 #define ctime_r __ctime_r50
 #define devname __devname50
+#define fgetpos __fgetpos50
+#define fsetpos __fsetpos50
 #define fts_children __fts_children60
 #define fts_close __fts_close60
 #define fts_open __fts_open60
 #define fts_read __fts_read60
 #define fts_set __fts_set60
 #define getitimer __getitimer50
 #define getmntinfo __getmntinfo13
 #define getpwent __getpwent50
#define INIT_MD5                                                               \
   COMMON_INTERCEPT_FUNCTION(MD5Final);                                         \
   COMMON_INTERCEPT_FUNCTION(MD5End);                                           \
   COMMON_INTERCEPT_FUNCTION(MD5File);                                          \
   COMMON_INTERCEPT_FUNCTION(MD5Data)
 #else
 #define INIT_MD5
 #endif
 
+#if SANITIZER_INTERCEPT_FSEEK
+INTERCEPTOR(int, fseek, __sanitizer_FILE *stream, long int offset, int whence) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fseek, stream, offset, whence);
+  return REAL(fseek)(stream, offset, whence);
+}
+INTERCEPTOR(int, fseeko, __sanitizer_FILE *stream, OFF_T offset, int whence) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fseeko, stream, offset, whence);
+  return REAL(fseeko)(stream, offset, whence);
+}
+INTERCEPTOR(long int, ftell, __sanitizer_FILE *stream) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ftell, stream);
+  return REAL(ftell)(stream);
+}
+INTERCEPTOR(OFF_T, ftello, __sanitizer_FILE *stream) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ftello, stream);
+  return REAL(ftello)(stream);
+}
+INTERCEPTOR(void, rewind, __sanitizer_FILE *stream) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, rewind, stream);
+  return REAL(rewind)(stream);
+}
+INTERCEPTOR(int, fgetpos, __sanitizer_FILE *stream, void *pos) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fgetpos, stream, pos);
+  int ret = REAL(fgetpos)(stream, pos);
+  if (pos && !ret)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, pos, fpos_t_sz);
+  return ret;
+}
+INTERCEPTOR(int, fsetpos, __sanitizer_FILE *stream, const void *pos) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fsetpos, stream, pos);
+  if (pos)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, pos, fpos_t_sz);
+  return REAL(fsetpos)(stream, pos);
+}
+#define INIT_FSEEK \
+  COMMON_INTERCEPT_FUNCTION(fseek); \
+  COMMON_INTERCEPT_FUNCTION(fseeko); \
+  COMMON_INTERCEPT_FUNCTION(ftell); \
+  COMMON_INTERCEPT_FUNCTION(ftello); \
+  COMMON_INTERCEPT_FUNCTION(rewind); \
+  COMMON_INTERCEPT_FUNCTION(fgetpos); \
+  COMMON_INTERCEPT_FUNCTION(fsetpos)
+#else
+#define INIT_FSEEK
+#endif
+
 static void InitializeCommonInterceptors() {
   static u64 metadata_mem[sizeof(MetadataHashMap) / sizeof(u64) + 1];
   interceptor_metadata_map =
       new ((void *)&metadata_mem) MetadataHashMap();  // NOLINT
 
   INIT_MMAP;
   INIT_MMAP64;
   INIT_TEXTDOMAIN;
static void InitializeCommonInterceptors() {
   INIT_FPARSELN;
   INIT_STATVFS1;
   INIT_STRTOI;
   INIT_CAPSICUM;
   INIT_SHA1;
   INIT_MD4;
   INIT_RMD160;
   INIT_MD5;
+  INIT_FSEEK;
 
   INIT___PRINTF_CHK;
 }

lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT_FPARSELN SI_NETBSD
 #define SANITIZER_INTERCEPT_STATVFS1 SI_NETBSD
 #define SANITIZER_INTERCEPT_STRTOI SI_NETBSD
 #define SANITIZER_INTERCEPT_CAPSICUM SI_FREEBSD
 #define SANITIZER_INTERCEPT_SHA1 SI_NETBSD
 #define SANITIZER_INTERCEPT_MD4 SI_NETBSD
 #define SANITIZER_INTERCEPT_RMD160 SI_NETBSD
 #define SANITIZER_INTERCEPT_MD5 SI_NETBSD
+#define SANITIZER_INTERCEPT_FSEEK SI_NETBSD
 
 #endif  // #ifndef SANITIZER_PLATFORM_INTERCEPTORS_H

lib/sanitizer_common/sanitizer_platform_limits_netbsd.h

 extern const unsigned MD4_CTX_sz;
 extern const unsigned MD4_return_length;
 
 extern const unsigned RMD160_CTX_sz;
 extern const unsigned RMD160_return_length;
 
 extern const unsigned MD5_CTX_sz;
 extern const unsigned MD5_return_length;
+
+extern const unsigned fpos_t_sz;
 }  // namespace __sanitizer
 
 #define CHECK_TYPE_SIZE(TYPE) \
   COMPILER_CHECK(sizeof(__sanitizer_##TYPE) == sizeof(TYPE))
 
 #define CHECK_SIZE_AND_OFFSET(CLASS, MEMBER)                      \
   COMPILER_CHECK(sizeof(((__sanitizer_##CLASS *)NULL)->MEMBER) == \
                  sizeof(((CLASS *)NULL)->MEMBER));                \

lib/sanitizer_common/sanitizer_platform_limits_netbsd.cc

 const unsigned MD4_CTX_sz = sizeof(MD4_CTX);
 const unsigned MD4_return_length = MD4_DIGEST_STRING_LENGTH;
 
 const unsigned RMD160_CTX_sz = sizeof(RMD160_CTX);
 const unsigned RMD160_return_length = RMD160_DIGEST_STRING_LENGTH;
 
 const unsigned MD5_CTX_sz = sizeof(MD5_CTX);
 const unsigned MD5_return_length = MD5_DIGEST_STRING_LENGTH;
+
+const unsigned fpos_t_sz = sizeof(fpos_t);
 }  // namespace __sanitizer
 
 using namespace __sanitizer;
 
 COMPILER_CHECK(sizeof(__sanitizer_pthread_attr_t) >= sizeof(pthread_attr_t));
 
 COMPILER_CHECK(sizeof(socklen_t) == sizeof(unsigned));
 CHECK_TYPE_SIZE(pthread_key_t);

test/sanitizer_common/TestCases/NetBSD/fseek.cc

+// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <inttypes.h>
+#include <stdio.h>
+
+int main(void) {
+  printf("fseek\n");
+
+  FILE *fp = fopen("/etc/fstab", "r");
+  assert(fp);
+
+  int rv = fseek(fp, 10, SEEK_SET);
+  assert(!rv);
+
+  printf("position: %ld\n", ftell(fp));
+
+  rewind(fp);
+
+  printf("position: %ld\n", ftell(fp));
+
+  rv = fseeko(fp, 15, SEEK_SET);
+  assert(!rv);
+
+  printf("position: %" PRIuMAX "\n", (uintmax_t)ftello(fp));
+
+  fpos_t pos;
+  rv = fgetpos(fp, &pos);
+  assert(!rv);
+
+  rewind(fp);
+
+  printf("position: %" PRIuMAX "\n", (uintmax_t)ftello(fp));
+
+  rv = fsetpos(fp, &pos);
+  assert(!rv);
+
+  printf("position: %" PRIuMAX "\n", (uintmax_t)ftello(fp));
+
+  rv = fclose(fp);
+  assert(!rv);
+
+  // CHECK: fseek
+  // CHECK: position: 10
+  // CHECK: position: 0
+  // CHECK: position: 15
+  // CHECK: position: 0
+  // CHECK: position: 15
+
+  return 0;
+}